ANSIfy

4 files changed, 966 insertions, 1013 deletions

diff --git a/generic/tkGrab.c b/generic/tkGrab.c
index bdf8497..b9b1d3d 100644
--- a/generic/tkGrab.c
+++ b/generic/tkGrab.c
@@ -1,15 +1,15 @@
-/* 
+/*
  * tkGrab.c --
  *
- *	This file provides procedures that implement grabs for Tk.
+ *	This file provides functions that implement grabs for Tk.
  *
  * Copyright (c) 1992-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: tkGrab.c,v 1.10 2004/03/17 18:15:43 das Exp $
+ * RCS: @(#) $Id: tkGrab.c,v 1.11 2005/11/14 22:44:11 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -20,28 +20,26 @@
 #endif
 
 /*
- * The grab state machine has four states: ungrabbed, button pressed,
- * grabbed, and button pressed while grabbed.  In addition, there are
- * three pieces of grab state information: the current grab window,
- * the current restrict window, and whether the mouse is captured.
- *
- * The current grab window specifies the point in the Tk window
- * heirarchy above which pointer events will not be reported.  Any
- * window within the subtree below the grab window will continue to
- * receive events as normal.  Events outside of the grab tree will be
- * reported to the grab window.
- *
- * If the current restrict window is set, then all pointer events will
- * be reported only to the restrict window.  The restrict window is
- * normally set during an automatic button grab.
- *
- * The mouse capture state specifies whether the window system will
- * report mouse events outside of any Tk toplevels.  This is set
- * during a global grab or an automatic button grab.
- *
- * The transitions between different states is given in the following
- * table:
- * 
+ * The grab state machine has four states: ungrabbed, button pressed, grabbed,
+ * and button pressed while grabbed. In addition, there are three pieces of
+ * grab state information: the current grab window, the current restrict
+ * window, and whether the mouse is captured.
+ *
+ * The current grab window specifies the point in the Tk window heirarchy
+ * above which pointer events will not be reported. Any window within the
+ * subtree below the grab window will continue to receive events as normal.
+ * Events outside of the grab tree will be reported to the grab window.
+ *
+ * If the current restrict window is set, then all pointer events will be
+ * reported only to the restrict window. The restrict window is normally set
+ * during an automatic button grab.
+ *
+ * The mouse capture state specifies whether the window system will report
+ * mouse events outside of any Tk toplevels. This is set during a global grab
+ * or an automatic button grab.
+ *
+ * The transitions between different states is given in the following table:
+ *
  * Event\State	U	B	G	GB
  * -----------	--	--	--	--
  * FirstPress	B	B	GB	GB
@@ -62,15 +60,14 @@
  * Grabbed		 1		0		b/g
  * Grab and Button	 1		1		1
  *
- * Note: 0 means variable is set to NULL, 1 means variable is set to
- * some window, b/g means the variable is set to a window if a button
- * is currently down or a global grab is in effect.
+ * Note: 0 means variable is set to NULL, 1 means variable is set to some
+ * window, b/g means the variable is set to a window if a button is currently
+ * down or a global grab is in effect.
  *
- * The final complication to all of this is enter and leave events.
- * In order to correctly handle all of the various cases, Tk cannot
- * rely on X enter/leave events in all situations.  The following
- * describes the correct sequence of enter and leave events that
- * should be observed by Tk scripts:
+ * The final complication to all of this is enter and leave events. In order
+ * to correctly handle all of the various cases, Tk cannot rely on X
+ * enter/leave events in all situations. The following describes the correct
+ * sequence of enter and leave events that should be observed by Tk scripts:
  *
  * Event(state)		Enter/Leave From -> To
  * ------------		----------------------
@@ -82,13 +79,13 @@
  * Ungrab(G):		anc(grab window, event window) -> event window
  * Ungrab(GB):		restrict window -> event window
  *
- * Note: anc(x,y) returns the least ancestor of y that is in the tree
- * of x, terminating at toplevels.
+ * Note: anc(x,y) returns the least ancestor of y that is in the tree of x,
+ * terminating at toplevels.
  */
 
 /*
- * The following structure is used to pass information to 
- * GrabRestrictProc from EatGrabEvents.
+ * The following structure is used to pass information to GrabRestrictProc
+ * from EatGrabEvents.
  */
 
 typedef struct {
@@ -101,47 +98,46 @@ typedef struct {
  *
  * GRAB_GLOBAL			1 means this is a global grab (we grabbed via
  *				the server so all applications are locked out).
- *				0 means this is a local grab that affects
- *				only this application.
+ *				0 means this is a local grab that affects only
+ *				this application.
  * GRAB_TEMP_GLOBAL		1 means we've temporarily grabbed via the
- *				server because a button is down and we want
- *				to make sure that we get the button-up
- *				event.  The grab will be released when the
- *				last mouse button goes up.
+ *				server because a button is down and we want to
+ *				make sure that we get the button-up event. The
+ *				grab will be released when the last mouse
+ *				button goes up.
  */
 
 #define GRAB_GLOBAL		1
 #define GRAB_TEMP_GLOBAL	4
 
 /*
- * The following structure is a Tcl_Event that triggers a change in
- * the grabWinPtr field of a display.  This event guarantees that
- * the change occurs in the proper order relative to enter and leave
- * events.
+ * The following structure is a Tcl_Event that triggers a change in the
+ * grabWinPtr field of a display. This event guarantees that the change occurs
+ * in the proper order relative to enter and leave events.
  */
 
 typedef struct NewGrabWinEvent {
     Tcl_Event header;		/* Standard information for all Tcl events. */
     TkDisplay *dispPtr;		/* Display whose grab window is to change. */
-    Window grabWindow;		/* New grab window for display.  This is
+    Window grabWindow;		/* New grab window for display. This is
 				 * recorded instead of a (TkWindow *) because
-				 * it will allow us to detect cases where
-				 * the window is destroyed before this event
-				 * is processed. */
+				 * it will allow us to detect cases where the
+				 * window is destroyed before this event is
+				 * processed. */
 } NewGrabWinEvent;
 
 /*
  * The following magic value is stored in the "send_event" field of
- * EnterNotify and LeaveNotify events that are generated in this
- * file.  This allows us to separate "real" events coming from the
- * server from those that we generated.
+ * EnterNotify and LeaveNotify events that are generated in this file. This
+ * allows us to separate "real" events coming from the server from those that
+ * we generated.
  */
 
 #define GENERATED_EVENT_MAGIC ((Bool) 0x147321ac)
 
 /*
- * Mask that selects any of the state bits corresponding to buttons,
- * plus masks that select individual buttons' bits:
+ * Mask that selects any of the state bits corresponding to buttons, plus
+ * masks that select individual buttons' bits:
  */
 
 #define ALL_BUTTONS \
@@ -151,32 +147,27 @@ static unsigned int buttonStates[] = {
 };
 
 /*
- * Forward declarations for procedures declared later in this file:
+ * Forward declarations for functions declared later in this file:
  */
 
-static void		EatGrabEvents _ANSI_ARGS_((TkDisplay *dispPtr,
-			    unsigned int serial));
-static TkWindow *	FindCommonAncestor _ANSI_ARGS_((TkWindow *winPtr1,
-			    TkWindow *winPtr2, int *countPtr1,
-			    int *countPtr2));
-static Tk_RestrictAction GrabRestrictProc _ANSI_ARGS_((ClientData arg,
-			    XEvent *eventPtr));
-static int		GrabWinEventProc _ANSI_ARGS_((Tcl_Event *evPtr,
-			    int flags));
-static void		MovePointer2 _ANSI_ARGS_((TkWindow *sourcePtr,
-			    TkWindow *destPtr, int mode, int leaveEvents,
-			    int EnterEvents));
-static void		QueueGrabWindowChange _ANSI_ARGS_((TkDisplay *dispPtr,
-			    TkWindow *grabWinPtr));
-static void		ReleaseButtonGrab _ANSI_ARGS_((TkDisplay *dispPtr));
+static void		EatGrabEvents(TkDisplay *dispPtr, unsigned int serial);
+static TkWindow *	FindCommonAncestor(TkWindow *winPtr1,
+			    TkWindow *winPtr2, int *countPtr1, int *countPtr2);
+static Tk_RestrictAction GrabRestrictProc(ClientData arg, XEvent *eventPtr);
+static int		GrabWinEventProc(Tcl_Event *evPtr, int flags);
+static void		MovePointer2(TkWindow *sourcePtr, TkWindow *destPtr,
+			    int mode, int leaveEvents, int EnterEvents);
+static void		QueueGrabWindowChange(TkDisplay *dispPtr,
+			    TkWindow *grabWinPtr);
+static void		ReleaseButtonGrab(TkDisplay *dispPtr);
 
 /*
  *----------------------------------------------------------------------
  *
  * Tk_GrabObjCmd --
  *
- *	This procedure is invoked to process the "grab" Tcl command.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the "grab" Tcl command. See the
+ *	user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -189,12 +180,11 @@ static void		ReleaseButtonGrab _ANSI_ARGS_((TkDisplay *dispPtr));
 
 	/* ARGSUSED */
 int
-Tk_GrabObjCmd(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_GrabObjCmd(
+    ClientData clientData,	/* Main window associated with interpreter. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument objects. */
 {
     int globalGrab;
     Tk_Window tkwin;
@@ -202,14 +192,16 @@ Tk_GrabObjCmd(clientData, interp, objc, objv)
     char *arg;
     int index;
     int len;
-    static CONST char *optionStrings[] = { "current", "release",
-					 "set", "status", (char *) NULL };
-  
-    static CONST char *flagStrings[] = { "-global", (char *) NULL };
-
-    enum options { GRABCMD_CURRENT, GRABCMD_RELEASE,
-		       GRABCMD_SET, GRABCMD_STATUS };
-    
+    static CONST char *optionStrings[] = {
+	"current", "release", "set", "status", NULL
+    };
+    static CONST char *flagStrings[] = {
+	"-global", NULL
+    };
+    enum options {
+	GRABCMD_CURRENT, GRABCMD_RELEASE, GRABCMD_SET, GRABCMD_STATUS
+    };
+
     if (objc < 2) {
 	/*
 	 * Can't use Tcl_WrongNumArgs here because we want the message to
@@ -223,8 +215,7 @@ Tk_GrabObjCmd(clientData, interp, objc, objv)
 	Tcl_ResetResult(interp);
 	Tcl_AppendResult(interp, "wrong # args: should be \"",
 		Tcl_GetString(objv[0]), " ?-global? window\" or \"",
-		Tcl_GetString(objv[0]), " option ?arg arg ...?\"",
-		(char *) NULL);
+		Tcl_GetString(objv[0]), " option ?arg arg ...?\"", NULL);
 	return TCL_ERROR;
     }
 
@@ -264,115 +255,114 @@ Tk_GrabObjCmd(clientData, interp, objc, objv)
     }
 
     /*
-     * First argument is not a window name and not "-global", find out
-     * which option it is.
+     * First argument is not a window name and not "-global", find out which
+     * option it is.
      */
 
     if (Tcl_GetIndexFromObj(interp, objv[1], optionStrings, "option", 0,
 	    &index) != TCL_OK) {
 	return TCL_ERROR;
     }
-    
+
     switch ((enum options) index) {
-	case GRABCMD_CURRENT: {
-	    /* [grab current ?window?] */
-	    if (objc > 3) {
-		Tcl_WrongNumArgs(interp, 1, objv, "current ?window?");
+    case GRABCMD_CURRENT:
+	/* [grab current ?window?] */
+	if (objc > 3) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "current ?window?");
+	    return TCL_ERROR;
+	}
+	if (objc == 3) {
+	    tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[2]),
+		    (Tk_Window) clientData);
+	    if (tkwin == NULL) {
 		return TCL_ERROR;
 	    }
-	    if (objc == 3) {
-		tkwin = Tk_NameToWindow(interp,
-			Tcl_GetString(objv[2]), (Tk_Window) clientData);
-		if (tkwin == NULL) {
-		    return TCL_ERROR;
-		}
-		dispPtr = ((TkWindow *) tkwin)->dispPtr;
+	    dispPtr = ((TkWindow *) tkwin)->dispPtr;
+	    if (dispPtr->eventualGrabWinPtr != NULL) {
+		Tcl_SetResult(interp, dispPtr->eventualGrabWinPtr->pathName,
+			TCL_STATIC);
+	    }
+	} else {
+	    for (dispPtr = TkGetDisplayList(); dispPtr != NULL;
+		    dispPtr = dispPtr->nextPtr) {
 		if (dispPtr->eventualGrabWinPtr != NULL) {
-		    Tcl_SetResult(interp,
-			    dispPtr->eventualGrabWinPtr->pathName, TCL_STATIC);
-		}
-	    } else {
-		for (dispPtr = TkGetDisplayList(); dispPtr != NULL;
-		     dispPtr = dispPtr->nextPtr) {
-		    if (dispPtr->eventualGrabWinPtr != NULL) {
-			Tcl_AppendElement(interp,
-				dispPtr->eventualGrabWinPtr->pathName);
-		    }
+		    Tcl_AppendElement(interp,
+			    dispPtr->eventualGrabWinPtr->pathName);
 		}
 	    }
-	    return TCL_OK;
 	}
+	return TCL_OK;
 
-	case GRABCMD_RELEASE: {
-	    /* [grab release window] */
-	    if (objc != 3) {
-		Tcl_WrongNumArgs(interp, 1, objv, "release window");
-		return TCL_ERROR;
-	    }
-	    tkwin = Tk_NameToWindow(interp,
-		    Tcl_GetString(objv[2]), (Tk_Window) clientData);
-	    if (tkwin == NULL) {
-		Tcl_ResetResult(interp);
-	    } else {
-		Tk_Ungrab(tkwin);
-	    }
-	    break;
+    case GRABCMD_RELEASE:
+	/* [grab release window] */
+	if (objc != 3) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "release window");
+	    return TCL_ERROR;
 	}
-	
-	case GRABCMD_SET: {
-	    /* [grab set ?-global? window] */
-	    if ((objc != 3) && (objc != 4)) {
-		Tcl_WrongNumArgs(interp, 1, objv, "set ?-global? window");
-		return TCL_ERROR;
-	    }
-	    if (objc == 3) {
-		globalGrab = 0;
-		tkwin = Tk_NameToWindow(interp,
-			Tcl_GetString(objv[2]), (Tk_Window) clientData);
-	    } else {
-		globalGrab = 1;
-		/*
-		 * We could just test the argument by hand instead of using
-		 * Tcl_GetIndexFromObj; the benefit of using the function is
-		 * that it sets up the error message for us, so we are
-		 * certain to be consistant with the rest of Tcl.
-		 */
-		if (Tcl_GetIndexFromObj(interp, objv[2], flagStrings, "option",
-			0, &index) != TCL_OK) {
-		    return TCL_ERROR;
-		}
-		tkwin = Tk_NameToWindow(interp,
-			Tcl_GetString(objv[3]), (Tk_Window) clientData);
-	    }
-	    if (tkwin == NULL) {
-		return TCL_ERROR;
-	    }
-	    return Tk_Grab(interp, tkwin, globalGrab);
+	tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[2]),
+		(Tk_Window) clientData);
+	if (tkwin == NULL) {
+	    Tcl_ResetResult(interp);
+	} else {
+	    Tk_Ungrab(tkwin);
 	}
+	break;
 
-	case GRABCMD_STATUS: {
-	    /* [grab status window] */
-	    TkWindow *winPtr;
+    case GRABCMD_SET:
+	/* [grab set ?-global? window] */
+	if ((objc != 3) && (objc != 4)) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "set ?-global? window");
+	    return TCL_ERROR;
+	}
+	if (objc == 3) {
+	    globalGrab = 0;
+	    tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[2]),
+		    (Tk_Window) clientData);
+	} else {
+	    globalGrab = 1;
 
-	    if (objc != 3) {
-		Tcl_WrongNumArgs(interp, 1, objv, "status window");
-		return TCL_ERROR;
-	    }
-	    winPtr = (TkWindow *) Tk_NameToWindow(interp,
-		    Tcl_GetString(objv[2]), (Tk_Window) clientData);
-	    if (winPtr == NULL) {
+	    /*
+	     * We could just test the argument by hand instead of using
+	     * Tcl_GetIndexFromObj; the benefit of using the function is that
+	     * it sets up the error message for us, so we are certain to be
+	     * consistant with the rest of Tcl.
+	     */
+
+	    if (Tcl_GetIndexFromObj(interp, objv[2], flagStrings, "option",
+		    0, &index) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    dispPtr = winPtr->dispPtr;
-	    if (dispPtr->eventualGrabWinPtr != winPtr) {
-		Tcl_SetResult(interp, "none", TCL_STATIC);
-	    } else if (dispPtr->grabFlags & GRAB_GLOBAL) {
-		Tcl_SetResult(interp, "global", TCL_STATIC);
-	    } else {
-		Tcl_SetResult(interp, "local", TCL_STATIC);
-	    }
-	    break;
+	    tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[3]),
+		    (Tk_Window) clientData);
+	}
+	if (tkwin == NULL) {
+	    return TCL_ERROR;
+	}
+	return Tk_Grab(interp, tkwin, globalGrab);
+
+    case GRABCMD_STATUS: {
+	/* [grab status window] */
+	TkWindow *winPtr;
+
+	if (objc != 3) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "status window");
+	    return TCL_ERROR;
+	}
+	winPtr = (TkWindow *) Tk_NameToWindow(interp, Tcl_GetString(objv[2]),
+		(Tk_Window) clientData);
+	if (winPtr == NULL) {
+	    return TCL_ERROR;
+	}
+	dispPtr = winPtr->dispPtr;
+	if (dispPtr->eventualGrabWinPtr != winPtr) {
+	    Tcl_SetResult(interp, "none", TCL_STATIC);
+	} else if (dispPtr->grabFlags & GRAB_GLOBAL) {
+	    Tcl_SetResult(interp, "global", TCL_STATIC);
+	} else {
+	    Tcl_SetResult(interp, "local", TCL_STATIC);
 	}
+	break;
+    }
     }
 
     return TCL_OK;
@@ -383,34 +373,32 @@ Tk_GrabObjCmd(clientData, interp, objc, objv)
  *
  * Tk_Grab --
  *
- *	Grabs the pointer and keyboard, so that mouse-related events are
- *	only reported relative to a given window and its descendants.
+ *	Grabs the pointer and keyboard, so that mouse-related events are only
+ *	reported relative to a given window and its descendants.
  *
  * Results:
- *	A standard Tcl result is returned.  TCL_OK is the normal return
- *	value;  if the grab could not be set then TCL_ERROR is returned
- *	and the interp's result will hold an error message.
+ *	A standard Tcl result is returned. TCL_OK is the normal return value;
+ *	if the grab could not be set then TCL_ERROR is returned and the
+ *	interp's result will hold an error message.
  *
  * Side effects:
- *	Once this call completes successfully, no window outside the
- *	tree rooted at tkwin will receive pointer- or keyboard-related
- *	events until the next call to Tk_Ungrab.  If a previous grab was
- *	in effect within this application, then it is replaced with a new
- *	one.
+ *	Once this call completes successfully, no window outside the tree
+ *	rooted at tkwin will receive pointer- or keyboard-related events until
+ *	the next call to Tk_Ungrab. If a previous grab was in effect within
+ *	this application, then it is replaced with a new one.
  *
  *----------------------------------------------------------------------
  */
 
 int
-Tk_Grab(interp, tkwin, grabGlobal)
-    Tcl_Interp *interp;			/* Used for error reporting. */
-    Tk_Window tkwin;			/* Window on whose behalf the pointer
-					 * is to be grabbed. */
-    int grabGlobal;			/* Non-zero means issue a grab to the
-					 * server so that no other application
-					 * gets mouse or keyboard events.
-					 * Zero means the grab only applies
-					 * within this application. */
+Tk_Grab(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tk_Window tkwin,		/* Window on whose behalf the pointer is to be
+				 * grabbed. */
+    int grabGlobal)		/* Non-zero means issue a grab to the server
+				 * so that no other application gets mouse or
+				 * keyboard events. Zero means the grab only
+				 * applies within this application. */
 {
     int grabResult, numTries;
     TkWindow *winPtr = (TkWindow *) tkwin;
@@ -425,7 +413,7 @@ Tk_Grab(interp, tkwin, grabGlobal)
 	    return TCL_OK;
 	}
 	if (dispPtr->eventualGrabWinPtr->mainPtr != winPtr->mainPtr) {
-	    alreadyGrabbed:
+	alreadyGrabbed:
 	    Tcl_SetResult(interp, "grab failed: another application has grab",
 		    TCL_STATIC);
 	    return TCL_ERROR;
@@ -440,11 +428,11 @@ Tk_Grab(interp, tkwin, grabGlobal)
 	unsigned int state;
 
 	/*
-	 * Local grab.  However, if any mouse buttons are down, turn
-	 * it into a global grab temporarily, until the last button
-	 * goes up.  This does two things: (a) it makes sure that we
-	 * see the button-up event;  and (b) it allows us to track mouse
-	 * motion among all of the windows of this application.
+	 * Local grab. However, if any mouse buttons are down, turn it into a
+	 * global grab temporarily, until the last button goes up. This does
+	 * two things: (a) it makes sure that we see the button-up event; and
+	 * (b) it allows us to track mouse motion among all of the windows of
+	 * this application.
 	 */
 
 	dispPtr->grabFlags &= ~(GRAB_GLOBAL|GRAB_TEMP_GLOBAL);
@@ -456,30 +444,28 @@ Tk_Grab(interp, tkwin, grabGlobal)
 	}
     } else {
 	dispPtr->grabFlags |= GRAB_GLOBAL;
-	setGlobalGrab:
+    setGlobalGrab:
 
 	/*
-	 * Tricky point: must ungrab before grabbing.  This is needed
-	 * in case there is a button auto-grab already in effect.  If
-	 * there is, and the mouse has moved to a different window, X
-	 * won't generate enter and leave events to move the mouse if
-	 * we grab without ungrabbing.
+	 * Tricky point: must ungrab before grabbing. This is needed in case
+	 * there is a button auto-grab already in effect. If there is, and the
+	 * mouse has moved to a different window, X won't generate enter and
+	 * leave events to move the mouse if we grab without ungrabbing.
 	 */
 
 	XUngrabPointer(dispPtr->display, CurrentTime);
 	serial = NextRequest(dispPtr->display);
 
 	/*
-	 * Another tricky point: there are races with some window
-	 * managers that can cause grabs to fail because the window
-	 * manager hasn't released its grab quickly enough.  To work
-	 * around this problem, retry a few times after AlreadyGrabbed
-	 * errors to give the grab release enough time to register with
-	 * the server.
+	 * Another tricky point: there are races with some window managers
+	 * that can cause grabs to fail because the window manager hasn't
+	 * released its grab quickly enough. To work around this problem,
+	 * retry a few times after AlreadyGrabbed errors to give the grab
+	 * release enough time to register with the server.
 	 */
 
-	grabResult = 0;			/* Needed only to prevent gcc
-					 * compiler warnings. */
+	grabResult = 0;			/* Needed only to prevent gcc compiler
+					 * warnings. */
 	for (numTries = 0; numTries < 10; numTries++) {
 	    grabResult = XGrabPointer(dispPtr->display, winPtr->window,
 		    True, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask
@@ -491,7 +477,7 @@ Tk_Grab(interp, tkwin, grabGlobal)
 	    Tcl_Sleep(100);
 	}
 	if (grabResult != 0) {
-	    grabError:
+	grabError:
 	    if (grabResult == GrabNotViewable) {
 		Tcl_SetResult(interp, "grab failed: window not viewable",
 			TCL_STATIC);
@@ -505,10 +491,10 @@ Tk_Grab(interp, tkwin, grabGlobal)
 			TCL_STATIC);
 	    } else {
 		char msg[64 + TCL_INTEGER_SPACE];
-	
+
 		sprintf(msg, "grab failed for unknown reason (code %d)",
 			grabResult);
-		Tcl_AppendResult(interp, msg, (char *) NULL);
+		Tcl_AppendResult(interp, msg, NULL);
 	    }
 	    return TCL_ERROR;
 	}
@@ -521,13 +507,13 @@ Tk_Grab(interp, tkwin, grabGlobal)
 
 	/*
 	 * Eat up any grab-related events generated by the server for the
-	 * grab.  There are several reasons for doing this:
+	 * grab. There are several reasons for doing this:
 	 *
 	 * 1. We have to synthesize the events for local grabs anyway, since
 	 *    the server doesn't participate in them.
 	 * 2. The server doesn't always generate the right events for global
-	 *    grabs (e.g. it generates events even if the current window is
-	 *    in the grab tree, which we don't want).
+	 *    grabs (e.g. it generates events even if the current window is in
+	 *    the grab tree, which we don't want).
 	 * 3. We want all the grab-related events to be processed immediately
 	 *    (before other events that are already queued); events coming
 	 *    from the server will be in the wrong place, but events we
@@ -538,8 +524,8 @@ Tk_Grab(interp, tkwin, grabGlobal)
     }
 
     /*
-     * Synthesize leave events to move the pointer from its current window
-     * up to the lowest ancestor that it has in common with the grab window.
+     * Synthesize leave events to move the pointer from its current window up
+     * to the lowest ancestor that it has in common with the grab window.
      * However, only do this if the pointer is outside the grab window's
      * subtree but inside the grab window's application.
      */
@@ -565,8 +551,8 @@ Tk_Grab(interp, tkwin, grabGlobal)
  *
  * Tk_Ungrab --
  *
- *	Releases a grab on the mouse pointer and keyboard, if there
- *	is one set on the specified window.
+ *	Releases a grab on the mouse pointer and keyboard, if there is one set
+ *	on the specified window.
  *
  * Results:
  *	None.
@@ -579,9 +565,8 @@ Tk_Grab(interp, tkwin, grabGlobal)
  */
 
 void
-Tk_Ungrab(tkwin)
-    Tk_Window tkwin;			/* Window whose grab should be
-					 * released. */
+Tk_Ungrab(
+    Tk_Window tkwin)		/* Window whose grab should be released. */
 {
     TkDisplay *dispPtr;
     TkWindow *grabWinPtr, *winPtr;
@@ -593,7 +578,7 @@ Tk_Ungrab(tkwin)
 	return;
     }
     ReleaseButtonGrab(dispPtr);
-    QueueGrabWindowChange(dispPtr, (TkWindow *) NULL);
+    QueueGrabWindowChange(dispPtr, NULL);
     if (dispPtr->grabFlags & (GRAB_GLOBAL|GRAB_TEMP_GLOBAL)) {
 	dispPtr->grabFlags &= ~(GRAB_GLOBAL|GRAB_TEMP_GLOBAL);
 	serial = NextRequest(dispPtr->display);
@@ -603,17 +588,17 @@ Tk_Ungrab(tkwin)
     }
 
     /*
-     * Generate events to move the pointer back to the window where it
-     * really is.  Some notes:
-     * 1. As with grabs, only do this if the "real" window is not a
-     *    descendant of the grab window, since in this case the pointer
-     *    is already where it's supposed to be.
+     * Generate events to move the pointer back to the window where it really
+     * is. Some notes:
+     * 1. As with grabs, only do this if the "real" window is not a descendant
+     *    of the grab window, since in this case the pointer is already where
+     *    it's supposed to be.
      * 2. If the "real" window is in some other application then don't
-     *    generate any events at all, since everything's already been
-     *    reported correctly.
-     * 3. Only generate enter events.  Don't generate leave events,
-     *    because we never told the lower-level windows that they
-     *    had the pointer in the first place.
+     *    generate any events at all, since everything's already been reported
+     *    correctly.
+     * 3. Only generate enter events. Don't generate leave events, because we
+     *    never told the lower-level windows that they had the pointer in the
+     *    first place.
      */
 
     for (winPtr = dispPtr->serverWinPtr; ; winPtr = winPtr->parentPtr) {
@@ -636,26 +621,26 @@ Tk_Ungrab(tkwin)
  *
  * ReleaseButtonGrab --
  *
- *	This procedure is called to release a simulated button grab, if
- *	there is one in effect.  A button grab is present whenever
- *	dispPtr->buttonWinPtr is non-NULL or when the GRAB_TEMP_GLOBAL
- *	flag is set.
+ *	This function is called to release a simulated button grab, if there
+ *	is one in effect. A button grab is present whenever
+ *	dispPtr->buttonWinPtr is non-NULL or when the GRAB_TEMP_GLOBAL flag is
+ *	set.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	DispPtr->buttonWinPtr is reset to NULL, and enter and leave
- *	events are generated if necessary to move the pointer from
- *	the button grab window to its current window.
+ *	DispPtr->buttonWinPtr is reset to NULL, and enter and leave events are
+ *	generated if necessary to move the pointer from the button grab window
+ *	to its current window.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ReleaseButtonGrab(dispPtr)
-    register TkDisplay *dispPtr;	/* Display whose button grab is to be
-					 * released. */
+ReleaseButtonGrab(
+    register TkDisplay *dispPtr)/* Display whose button grab is to be
+				 * released. */
 {
     unsigned int serial;
 
@@ -680,64 +665,64 @@ ReleaseButtonGrab(dispPtr)
  *
  * TkPointerEvent --
  *
- *	This procedure is called for each pointer-related event, before
- *	the event has been processed.  It does various things to make
- *	grabs work correctly.
+ *	This function is called for each pointer-related event, before the
+ *	event has been processed. It does various things to make grabs work
+ *	correctly.
  *
  * Results:
- *	If the return value is 1 it means the event should be processed
- *	(event handlers should be invoked).  If the return value is 0
- *	it means the event should be ignored in order to make grabs
- *	work correctly.  In some cases this procedure modifies the event.
+ *	If the return value is 1 it means the event should be processed (event
+ *	handlers should be invoked). If the return value is 0 it means the
+ *	event should be ignored in order to make grabs work correctly. In some
+ *	cases this function modifies the event.
  *
  * Side effects:
- *	Grab state information may be updated.  New events may also be
- *	pushed back onto the event queue to replace or augment the
- *	one passed in here.
+ *	Grab state information may be updated. New events may also be pushed
+ *	back onto the event queue to replace or augment the one passed in
+ *	here.
  *
  *----------------------------------------------------------------------
  */
 
 int
-TkPointerEvent(eventPtr, winPtr)
-    register XEvent *eventPtr;		/* Pointer to the event. */
-    TkWindow *winPtr;			/* Tk's information for window
-					 * where event was reported. */
+TkPointerEvent(
+    register XEvent *eventPtr,	/* Pointer to the event. */
+    TkWindow *winPtr)		/* Tk's information for window where event was
+				 * reported. */
 {
     register TkWindow *winPtr2;
     TkDisplay *dispPtr = winPtr->dispPtr;
     unsigned int serial;
     int outsideGrabTree = 0;
     int ancestorOfGrab = 0;
-    int appGrabbed = 0;			/* Non-zero means event is being
-					 * reported to an application that is
-					 * affected by the grab. */
+    int appGrabbed = 0;		/* Non-zero means event is being reported to
+				 * an application that is affected by the
+				 * grab. */
 
     /*
      * Collect information about the grab (if any).
      */
 
     switch (TkGrabState(winPtr)) {
-	case TK_GRAB_IN_TREE:
-	    appGrabbed = 1;
-	    break;
-	case TK_GRAB_ANCESTOR:
-	    appGrabbed = 1;
-	    outsideGrabTree = 1;
-	    ancestorOfGrab = 1;
-	    break;
-	case TK_GRAB_EXCLUDED:
-	    appGrabbed = 1;
-	    outsideGrabTree = 1;
-	    break;
+    case TK_GRAB_IN_TREE:
+	appGrabbed = 1;
+	break;
+    case TK_GRAB_ANCESTOR:
+	appGrabbed = 1;
+	outsideGrabTree = 1;
+	ancestorOfGrab = 1;
+	break;
+    case TK_GRAB_EXCLUDED:
+	appGrabbed = 1;
+	outsideGrabTree = 1;
+	break;
     }
 
     if ((eventPtr->type == EnterNotify) || (eventPtr->type == LeaveNotify)) {
 	/*
-	 * Keep track of what window the mouse is *really* over.
-	 * Any events that we generate have a special send_event value,
-	 * which is detected below and used to ignore the event for
-	 * purposes of setting serverWinPtr.
+	 * Keep track of what window the mouse is *really* over. Any events
+	 * that we generate have a special send_event value, which is detected
+	 * below and used to ignore the event for purposes of setting
+	 * serverWinPtr.
 	 */
 
 	if (eventPtr->xcrossing.send_event != GENERATED_EVENT_MAGIC) {
@@ -750,13 +735,13 @@ TkPointerEvent(eventPtr, winPtr)
 	}
 
 	/*
-	 * When a grab is active, X continues to report enter and leave
-	 * events for windows outside the tree of the grab window:
-	 * 1. Detect these events and ignore them except for
-	 *    windows above the grab window.
-	 * 2. Allow Enter and Leave events to pass through the
-	 *    windows above the grab window, but never let them
-	 *    end up with the pointer *in* one of those windows.
+	 * When a grab is active, X continues to report enter and leave events
+	 * for windows outside the tree of the grab window:
+	 * 1. Detect these events and ignore them except for windows above the
+	 *    grab window.
+	 * 2. Allow Enter and Leave events to pass through the windows above
+	 *    the grab window, but never let them end up with the pointer *in*
+	 *    one of those windows.
 	 */
 
 	if (dispPtr->grabWinPtr != NULL) {
@@ -765,22 +750,21 @@ TkPointerEvent(eventPtr, winPtr)
 		    return 0;
 		}
 		switch (eventPtr->xcrossing.detail) {
-		    case NotifyInferior:
-			return 0;
-		    case NotifyAncestor:
-			eventPtr->xcrossing.detail = NotifyVirtual;
-			break;
-		    case NotifyNonlinear:
-			eventPtr->xcrossing.detail = NotifyNonlinearVirtual;
-			break;
+		case NotifyInferior:
+		    return 0;
+		case NotifyAncestor:
+		    eventPtr->xcrossing.detail = NotifyVirtual;
+		    break;
+		case NotifyNonlinear:
+		    eventPtr->xcrossing.detail = NotifyNonlinearVirtual;
+		    break;
 		}
 	    }
 
 	    /*
-	     * Make buttons have the same grab-like behavior inside a grab
-	     * as they do outside a grab:  do this by ignoring enter and
-	     * leave events except for the window in which the button was
-	     * pressed.
+	     * Make buttons have the same grab-like behavior inside a grab as
+	     * they do outside a grab: do this by ignoring enter and leave
+	     * events except for the window in which the button was pressed.
 	     */
 
 	    if ((dispPtr->buttonWinPtr != NULL)
@@ -798,12 +782,12 @@ TkPointerEvent(eventPtr, winPtr)
     if (eventPtr->type == MotionNotify) {
 	/*
 	 * When grabs are active, X reports motion events relative to the
-	 * window under the pointer.  Instead, it should report the events
+	 * window under the pointer. Instead, it should report the events
 	 * relative to the window the button went down in, if there is a
-	 * button down.  Otherwise, if the pointer window is outside the
-	 * subtree of the grab window, the events should be reported
-	 * relative to the grab window.  Otherwise, the event should be
-	 * reported to the pointer window.
+	 * button down. Otherwise, if the pointer window is outside the
+	 * subtree of the grab window, the events should be reported relative
+	 * to the grab window. Otherwise, the event should be reported to the
+	 * pointer window.
 	 */
 
 	winPtr2 = winPtr;
@@ -822,32 +806,32 @@ TkPointerEvent(eventPtr, winPtr)
 
     /*
      * Process ButtonPress and ButtonRelease events:
-     * 1. Keep track of whether a button is down and what window it
-     *    went down in.
-     * 2. If the first button goes down outside the grab tree, pretend
-     *    it went down in the grab window.  Note: it's important to
-     *    redirect events to the grab window like this in order to make
-     *    things like menus work, where button presses outside the
-     *    grabbed menu need to be seen.  An application can always
-     *    ignore the events if they occur outside its window.
-     * 3. If a button press or release occurs outside the window where
-     *    the first button was pressed, retarget the event so it's reported
-     *    to the window where the first button was pressed.
-     * 4. If the last button is released in a window different than where
-     *    the first button was pressed, generate Enter/Leave events to
-     *    move the mouse from the button window to its current window.
-     * 5. If the grab is set at a time when a button is already down, or
-     *    if the window where the button was pressed was deleted, then
-     *    dispPtr->buttonWinPtr will stay NULL.  Just forget about the
-     *    auto-grab for the button press;  events will go to whatever
-     *    window contains the pointer.  If this window isn't in the grab
-     *    tree then redirect events to the grab window.
-     * 6. When a button is pressed during a local grab, the X server sets
-     *    a grab of its own, since it doesn't even know about our local
-     *    grab.  This causes enter and leave events no longer to be
-     *    generated in the same way as for global grabs.  To eliminate this
-     *    problem, set a temporary global grab when the first button goes
-     *    down and release it when the last button comes up.
+     * 1. Keep track of whether a button is down and what window it went down
+     *    in.
+     * 2. If the first button goes down outside the grab tree, pretend it went
+     *    down in the grab window. Note: it's important to redirect events to
+     *    the grab window like this in order to make things like menus work,
+     *    where button presses outside the grabbed menu need to be seen. An
+     *    application can always ignore the events if they occur outside its
+     *    window.
+     * 3. If a button press or release occurs outside the window where the
+     *    first button was pressed, retarget the event so it's reported to the
+     *    window where the first button was pressed.
+     * 4. If the last button is released in a window different than where the
+     *    first button was pressed, generate Enter/Leave events to move the
+     *    mouse from the button window to its current window.
+     * 5. If the grab is set at a time when a button is already down, or if
+     *    the window where the button was pressed was deleted, then
+     *    dispPtr->buttonWinPtr will stay NULL. Just forget about the
+     *    auto-grab for the button press; events will go to whatever window
+     *    contains the pointer. If this window isn't in the grab tree then
+     *    redirect events to the grab window.
+     * 6. When a button is pressed during a local grab, the X server sets a
+     *    grab of its own, since it doesn't even know about our local grab.
+     *    This causes enter and leave events no longer to be generated in the
+     *    same way as for global grabs. To eliminate this problem, set a
+     *    temporary global grab when the first button goes down and release it
+     *    when the last button comes up.
      */
 
     if ((eventPtr->type == ButtonPress) || (eventPtr->type == ButtonRelease)) {
@@ -908,12 +892,12 @@ TkPointerEvent(eventPtr, winPtr)
  * TkChangeEventWindow --
  *
  *	Given an event and a new window to which the event should be
- *	retargeted, modify fields of the event so that the event is
- *	properly retargeted to the new window.
+ *	retargeted, modify fields of the event so that the event is properly
+ *	retargeted to the new window.
  *
  * Results:
- *	The following fields of eventPtr are modified:  window,
- *	subwindow, x, y, same_screen.
+ *	The following fields of eventPtr are modified: window, subwindow, x,
+ *	y, same_screen.
  *
  * Side effects:
  *	None.
@@ -922,12 +906,12 @@ TkPointerEvent(eventPtr, winPtr)
  */
 
 void
-TkChangeEventWindow(eventPtr, winPtr)
-    register XEvent *eventPtr;	/* Event to retarget.  Must have
-				 * type ButtonPress, ButtonRelease, KeyPress,
-				 * KeyRelease, MotionNotify, EnterNotify,
-				 * or LeaveNotify. */
-    TkWindow *winPtr;		/* New target window for event. */
+TkChangeEventWindow(
+    register XEvent *eventPtr,	/* Event to retarget. Must have type
+				 * ButtonPress, ButtonRelease, KeyPress,
+				 * KeyRelease, MotionNotify, EnterNotify, or
+				 * LeaveNotify. */
+    TkWindow *winPtr)		/* New target window for event. */
 {
     int x, y, sameScreen, bd;
     register TkWindow *childPtr;
@@ -972,44 +956,44 @@ TkChangeEventWindow(eventPtr, winPtr)
  *
  * TkInOutEvents --
  *
- *	This procedure synthesizes EnterNotify and LeaveNotify events
- *	to correctly transfer the pointer from one window to another.
- *	It can also be used to generate FocusIn and FocusOut events
- *	to move the input focus.
+ *	This function synthesizes EnterNotify and LeaveNotify events to
+ *	correctly transfer the pointer from one window to another. It can also
+ *	be used to generate FocusIn and FocusOut events to move the input
+ *	focus.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Synthesized events may be pushed back onto the event queue.
- *	The event pointed to by eventPtr is modified.
+ *	Synthesized events may be pushed back onto the event queue. The event
+ *	pointed to by eventPtr is modified.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
-    XEvent *eventPtr;		/* A template X event.  Must have all fields
+TkInOutEvents(
+    XEvent *eventPtr,		/* A template X event. Must have all fields
 				 * properly set except for type, window,
-				 * subwindow, x, y, detail, and same_screen
+				 * subwindow, x, y, detail, and same_screen.
 				 * (Not all of these fields are valid for
-				 * FocusIn/FocusOut events;  x_root and y_root
+				 * FocusIn/FocusOut events; x_root and y_root
 				 * must be valid for Enter/Leave events, even
 				 * though x and y needn't be valid). */
-    TkWindow *sourcePtr;	/* Window that used to have the pointer or
+    TkWindow *sourcePtr,	/* Window that used to have the pointer or
 				 * focus (NULL means it was not in a window
 				 * managed by this process). */
-    TkWindow *destPtr;		/* Window that is to end up with the pointer
+    TkWindow *destPtr,		/* Window that is to end up with the pointer
 				 * or focus (NULL means it's not one managed
 				 * by this process). */
-    int leaveType;		/* Type of events to generate for windows
-				 * being left (LeaveNotify or FocusOut).  0
+    int leaveType,		/* Type of events to generate for windows
+				 * being left (LeaveNotify or FocusOut). 0
 				 * means don't generate leave events. */
-    int enterType;		/* Type of events to generate for windows
-				 * being entered (EnterNotify or FocusIn).  0
+    int enterType,		/* Type of events to generate for windows
+				 * being entered (EnterNotify or FocusIn). 0
 				 * means don't generate enter events. */
-    Tcl_QueuePosition position;	/* Position at which events are added to
-				 * the system event queue. */
+    Tcl_QueuePosition position)	/* Position at which events are added to the
+				 * system event queue. */
 {
     register TkWindow *winPtr;
     int upLevels, downLevels, i, j, focus;
@@ -1017,17 +1001,15 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
     /*
      * There are four possible cases to deal with:
      *
-     * 1. SourcePtr and destPtr are the same.  There's nothing to do in
-     *    this case.
-     * 2. SourcePtr is an ancestor of destPtr in the same top-level
-     *    window.  Must generate events down the window tree from source
-     *    to dest.
-     * 3. DestPtr is an ancestor of sourcePtr in the same top-level
-     *    window.  Must generate events up the window tree from sourcePtr
-     *    to destPtr.
-     * 4. All other cases.  Must first generate events up the window tree
-     *    from sourcePtr to its top-level, then down from destPtr's
-     *    top-level to destPtr. This form is called "non-linear."
+     * 1. SourcePtr and destPtr are the same. There's nothing to do in this
+     *    case.
+     * 2. SourcePtr is an ancestor of destPtr in the same top-level window.
+     *    Must generate events down the window tree from source to dest.
+     * 3. DestPtr is an ancestor of sourcePtr in the same top-level window.
+     *    Must generate events up the window tree from sourcePtr to destPtr.
+     * 4. All other cases. Must first generate events up the window tree from
+     *    sourcePtr to its top-level, then down from destPtr's top-level to
+     *    destPtr. This form is called "non-linear."
      *
      * The call to FindCommonAncestor separates these four cases and decides
      * how many levels up and down events have to be generated for.
@@ -1047,7 +1029,6 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
      * Generate enter/leave events and add them to the grab event queue.
      */
 
-
 #define QUEUE(w, t, d)					\
     if (w->window != None) {				\
 	eventPtr->type = t;				\
@@ -1062,7 +1043,6 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
     }
 
     if (downLevels == 0) {
-    
 	/*
 	 * SourcePtr is an inferior of destPtr.
 	 */
@@ -1078,7 +1058,6 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
 	    QUEUE(destPtr, enterType, NotifyInferior);
 	}
     } else if (upLevels == 0) {
-
 	/*
 	 * DestPtr is an inferior of sourcePtr.
 	 */
@@ -1090,6 +1069,7 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
 	    for (i = downLevels-1; i > 0; i--) {
 		for (winPtr = destPtr->parentPtr, j = 1; j < i;
 			winPtr = winPtr->parentPtr, j++) {
+		    /* empty */
 		}
 		QUEUE(winPtr, enterType, NotifyVirtual);
 	    }
@@ -1098,9 +1078,8 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
 	    }
 	}
     } else {
-
 	/*
-	 * Non-linear:  neither window is an inferior of the other.
+	 * Non-linear: neither window is an inferior of the other.
 	 */
 
 	if (leaveType != 0) {
@@ -1129,11 +1108,11 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
  *
  * MovePointer2 --
  *
- *	This procedure synthesizes  EnterNotify and LeaveNotify events
- *	to correctly transfer the pointer from one window to another.
- *	It is different from TkInOutEvents in that no template X event
- *	needs to be supplied;  this procedure generates the template
- *	event and calls TkInOutEvents.
+ *	This function synthesizes EnterNotify and LeaveNotify events to
+ *	correctly transfer the pointer from one window to another. It is
+ *	different from TkInOutEvents in that no template X event needs to be
+ *	supplied; this function generates the template event and calls
+ *	TkInOutEvents.
  *
  * Results:
  *	None.
@@ -1145,20 +1124,20 @@ TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
  */
 
 static void
-MovePointer2(sourcePtr, destPtr, mode, leaveEvents, enterEvents)
-    TkWindow *sourcePtr;	/* Window currently containing pointer (NULL
+MovePointer2(
+    TkWindow *sourcePtr,	/* Window currently containing pointer (NULL
 				 * means it's not one managed by this
 				 * process). */
-    TkWindow *destPtr;		/* Window that is to end up containing the
-				 * pointer (NULL means it's not one managed
-				 * by this process). */
-    int mode;			/* Mode for enter/leave events, such as
+    TkWindow *destPtr,		/* Window that is to end up containing the
+				 * pointer (NULL means it's not one managed by
+				 * this process). */
+    int mode,			/* Mode for enter/leave events, such as
 				 * NotifyNormal or NotifyUngrab. */
-    int leaveEvents;		/* Non-zero means generate leave events for the
-				 * windows being left.  Zero means don't
+    int leaveEvents,		/* Non-zero means generate leave events for
+				 * the windows being left. Zero means don't
 				 * generate leave events. */
-    int enterEvents;		/* Non-zero means generate enter events for the
-				 * windows being entered.  Zero means don't
+    int enterEvents)		/* Non-zero means generate enter events for
+				 * the windows being entered. Zero means don't
 				 * generate enter events. */
 {
     XEvent event;
@@ -1174,12 +1153,10 @@ MovePointer2(sourcePtr, destPtr, mode, leaveEvents, enterEvents)
 	}
     }
 
-    event.xcrossing.serial = LastKnownRequestProcessed(
-	winPtr->display);
+    event.xcrossing.serial = LastKnownRequestProcessed(winPtr->display);
     event.xcrossing.send_event = GENERATED_EVENT_MAGIC;
     event.xcrossing.display = winPtr->display;
-    event.xcrossing.root = RootWindow(winPtr->display,
-	    winPtr->screenNum);
+    event.xcrossing.root = RootWindow(winPtr->display, winPtr->screenNum);
     event.xcrossing.time = TkCurrentTime(winPtr->dispPtr);
     XQueryPointer(winPtr->display, winPtr->window, &dummy1, &dummy2,
 	    &event.xcrossing.x_root, &event.xcrossing.y_root,
@@ -1195,30 +1172,30 @@ MovePointer2(sourcePtr, destPtr, mode, leaveEvents, enterEvents)
  *
  * TkGrabDeadWindow --
  *
- *	This procedure is invoked whenever a window is deleted, so that
+ *	This function is invoked whenever a window is deleted, so that
  *	grab-related cleanup can be performed.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Various cleanups happen, such as generating events to move the
- *	pointer back to its "natural" window as if an ungrab had been
- *	done.  See the code.
+ *	Various cleanups happen, such as generating events to move the pointer
+ *	back to its "natural" window as if an ungrab had been done. See the
+ *	code.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkGrabDeadWindow(winPtr)
-    register TkWindow *winPtr;		/* Window that is in the process
-					 * of being deleted. */
+TkGrabDeadWindow(
+    register TkWindow *winPtr)	/* Window that is in the process of being
+				 * deleted. */
 {
     TkDisplay *dispPtr = winPtr->dispPtr;
 
     if (dispPtr->eventualGrabWinPtr == winPtr) {
 	/*
-	 * Grab window was deleted.  Release the grab.
+	 * Grab window was deleted. Release the grab.
 	 */
 
 	Tk_Ungrab((Tk_Window) dispPtr->eventualGrabWinPtr);
@@ -1242,26 +1219,25 @@ TkGrabDeadWindow(winPtr)
  *
  * EatGrabEvents --
  *
- *	This procedure is called to eliminate any Enter, Leave,
- *	FocusIn, or FocusOut events in the event queue for a
- *	display that have mode NotifyGrab or NotifyUngrab and
- *	have a serial number no less than a given value and are not
- *	generated by the grab module.
+ *	This function is called to eliminate any Enter, Leave, FocusIn, or
+ *	FocusOut events in the event queue for a display that have mode
+ *	NotifyGrab or NotifyUngrab and have a serial number no less than a
+ *	given value and are not generated by the grab module.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	DispPtr's display gets sync-ed, and some of the events get
- *	removed from the Tk event queue.
+ *	DispPtr's display gets sync-ed, and some of the events get removed
+ *	from the Tk event queue.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-EatGrabEvents(dispPtr, serial)
-    TkDisplay *dispPtr;		/* Display from which to consume events. */
-    unsigned int serial;	/* Only discard events that have a serial
+EatGrabEvents(
+    TkDisplay *dispPtr,		/* Display from which to consume events. */
+    unsigned int serial)	/* Only discard events that have a serial
 				 * number at least this great. */
 {
     Tk_RestrictProc *oldProc;
@@ -1282,10 +1258,10 @@ EatGrabEvents(dispPtr, serial)
  *
  * GrabRestrictProc --
  *
- *	A Tk_RestrictProc used by EatGrabEvents to eliminate any
- *	Enter, Leave, FocusIn, or FocusOut events in the event queue
- *	for a display that has mode NotifyGrab or NotifyUngrab and
- *	have a serial number no less than a given value.
+ *	A Tk_RestrictProc used by EatGrabEvents to eliminate any Enter, Leave,
+ *	FocusIn, or FocusOut events in the event queue for a display that has
+ *	mode NotifyGrab or NotifyUngrab and have a serial number no less than
+ *	a given value.
  *
  * Results:
  *	Returns either TK_DISCARD_EVENT or TK_DEFER_EVENT.
@@ -1297,17 +1273,17 @@ EatGrabEvents(dispPtr, serial)
  */
 
 static Tk_RestrictAction
-GrabRestrictProc(arg, eventPtr)
-    ClientData arg;
-    XEvent *eventPtr;
+GrabRestrictProc(
+    ClientData arg,
+    XEvent *eventPtr)
 {
     GrabInfo *info = (GrabInfo *) arg;
     int mode, diff;
 
     /*
-     * The diff caculation is trickier than it may seem.  Don't forget
-     * that serial numbers can wrap around, so can't compare the two
-     * serial numbers directly.
+     * The diff caculation is trickier than it may seem. Don't forget that
+     * serial numbers can wrap around, so can't compare the two serial numbers
+     * directly.
      */
 
     diff = eventPtr->xany.serial - info->serial;
@@ -1333,29 +1309,28 @@ GrabRestrictProc(arg, eventPtr)
  *
  * QueueGrabWindowChange --
  *
- *	This procedure queues a special event in the Tcl event queue,
- *	which will cause the "grabWinPtr" field for the display to get
- *	modified when the event is processed.  This is needed to make
- *	sure that the grab window changes at the proper time relative
- *	to grab-related enter and leave events that are also in the
- *	queue.  In particular, this approach works even when multiple
- *	grabs and ungrabs happen back-to-back.
+ *	This function queues a special event in the Tcl event queue, which
+ *	will cause the "grabWinPtr" field for the display to get modified when
+ *	the event is processed. This is needed to make sure that the grab
+ *	window changes at the proper time relative to grab-related enter and
+ *	leave events that are also in the queue. In particular, this approach
+ *	works even when multiple grabs and ungrabs happen back-to-back.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	DispPtr->grabWinPtr will be modified later (by GrabWinEventProc)
- *	when the event is removed from the grab event queue.
+ *	DispPtr->grabWinPtr will be modified later (by GrabWinEventProc) when
+ *	the event is removed from the grab event queue.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-QueueGrabWindowChange(dispPtr, grabWinPtr)
-    TkDisplay *dispPtr;		/* Display on which to change the grab
+QueueGrabWindowChange(
+    TkDisplay *dispPtr,		/* Display on which to change the grab
 				 * window. */
-    TkWindow *grabWinPtr;	/* Window that is to become the new grab
+    TkWindow *grabWinPtr)	/* Window that is to become the new grab
 				 * window (may be NULL). */
 {
     NewGrabWinEvent *grabEvPtr;
@@ -1377,25 +1352,25 @@ QueueGrabWindowChange(dispPtr, grabWinPtr)
  *
  * GrabWinEventProc --
  *
- *	This procedure is invoked as a handler for Tcl_Events of type
- *	NewGrabWinEvent.  It updates the current grab window field in
- *	a display.
+ *	This function is invoked as a handler for Tcl_Events of type
+ *	NewGrabWinEvent. It updates the current grab window field in a
+ *	display.
  *
  * Results:
- *	Returns 1 if the event was processed, 0 if it should be deferred
- *	for processing later.
+ *	Returns 1 if the event was processed, 0 if it should be deferred for
+ *	processing later.
  *
  * Side effects:
- *	The grabWinPtr field is modified in the display associated with
- *	the event.
+ *	The grabWinPtr field is modified in the display associated with the
+ *	event.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-GrabWinEventProc(evPtr, flags)
-    Tcl_Event *evPtr;		/* Event of type NewGrabWinEvent. */
-    int flags;			/* Flags argument to Tk_DoOneEvent: indicates
+GrabWinEventProc(
+    Tcl_Event *evPtr,		/* Event of type NewGrabWinEvent. */
+    int flags)			/* Flags argument to Tk_DoOneEvent: indicates
 				 * what kinds of events are being processed
 				 * right now. */
 {
@@ -1411,19 +1386,19 @@ GrabWinEventProc(evPtr, flags)
  *
  * FindCommonAncestor --
  *
- *	Given two windows, this procedure finds their least common
- *	ancestor and also computes how many levels up this ancestor
- *	is from each of the original windows.
+ *	Given two windows, this function finds their least common ancestor and
+ *	also computes how many levels up this ancestor is from each of the
+ *	original windows.
  *
  * Results:
- *	If the windows are in different applications or top-level
- *	windows, then NULL is returned and *countPtr1 and *countPtr2
- *	are set to the depths of the two windows in their respective
- *	top-level windows (1 means the window is a top-level, 2 means
- *	its parent is a top-level, and so on).  Otherwise, the return
- *	value is a pointer to the common ancestor and the counts are
- *	set to the distance of winPtr1 and winPtr2 from this ancestor
- *	(1 means they're children, 2 means grand-children, etc.).
+ *	If the windows are in different applications or top-level windows,
+ *	then NULL is returned and *countPtr1 and *countPtr2 are set to the
+ *	depths of the two windows in their respective top-level windows (1
+ *	means the window is a top-level, 2 means its parent is a top-level,
+ *	and so on). Otherwise, the return value is a pointer to the common
+ *	ancestor and the counts are set to the distance of winPtr1 and winPtr2
+ *	from this ancestor (1 means they're children, 2 means grand-children,
+ *	etc.).
  *
  * Side effects:
  *	None.
@@ -1432,12 +1407,12 @@ GrabWinEventProc(evPtr, flags)
  */
 
 static TkWindow *
-FindCommonAncestor(winPtr1, winPtr2, countPtr1, countPtr2)
-    TkWindow *winPtr1;		/* First window.   May be NULL. */
-    TkWindow *winPtr2;		/* Second window.  May be NULL. */
-    int *countPtr1;		/* Store nesting level of winPtr1 within
+FindCommonAncestor(
+    TkWindow *winPtr1,		/* First window. May be NULL. */
+    TkWindow *winPtr2,		/* Second window. May be NULL. */
+    int *countPtr1,		/* Store nesting level of winPtr1 within
 				 * common ancestor here. */
-    int *countPtr2;		/* Store nesting level of winPtr2 within
+    int *countPtr2)		/* Store nesting level of winPtr2 within
 				 * common ancestor here. */
 {
     register TkWindow *winPtr;
@@ -1458,8 +1433,8 @@ FindCommonAncestor(winPtr1, winPtr2, countPtr1, countPtr2)
     }
 
     /*
-     * Search upwards from winPtr2 until an ancestor of winPtr1 is
-     * found or a top-level window is reached.
+     * Search upwards from winPtr2 until an ancestor of winPtr1 is found or a
+     * top-level window is reached.
      */
 
     winPtr = winPtr2;
@@ -1512,15 +1487,13 @@ FindCommonAncestor(winPtr1, winPtr2, countPtr1, countPtr2)
  *
  * TkPositionInTree --
  *
- *	Compute where the given window is relative to a particular
- *	subtree of the window hierarchy.
+ *	Compute where the given window is relative to a particular subtree of
+ *	the window hierarchy.
  *
  * Results:
- *
- *	Returns TK_GRAB_IN_TREE if the window is contained in the
- *	subtree.  Returns TK_GRAB_ANCESTOR if the window is an
- *	ancestor of the subtree, in the same toplevel.  Otherwise
- *	it returns TK_GRAB_EXCLUDED.
+ *	Returns TK_GRAB_IN_TREE if the window is contained in the subtree.
+ *	Returns TK_GRAB_ANCESTOR if the window is an ancestor of the subtree,
+ *	in the same toplevel. Otherwise it returns TK_GRAB_EXCLUDED.
  *
  * Side effects:
  *	None.
@@ -1529,9 +1502,9 @@ FindCommonAncestor(winPtr1, winPtr2, countPtr1, countPtr2)
  */
 
 int
-TkPositionInTree(winPtr, treePtr)
-    TkWindow *winPtr;		/* Window to be checked. */
-    TkWindow *treePtr;		/* Root of tree to compare against. */
+TkPositionInTree(
+    TkWindow *winPtr,		/* Window to be checked. */
+    TkWindow *treePtr)		/* Root of tree to compare against. */
 {
     TkWindow *winPtr2;
 
@@ -1558,21 +1531,20 @@ TkPositionInTree(winPtr, treePtr)
  *
  * TkGrabState --
  *
- *	Given a window, this procedure returns a value that indicates
- *	the grab state of the application relative to the window.
+ *	Given a window, this function returns a value that indicates the grab
+ *	state of the application relative to the window.
  *
  * Results:
  *	The return value is one of three things:
  *	    TK_GRAB_NONE -	no grab is in effect.
- *	    TK_GRAB_IN_TREE -   there is a grab in effect, and winPtr
- *				is in the grabbed subtree.
- *	    TK_GRAB_ANCESTOR -  there is a grab in effect;  winPtr is
- *				an ancestor of the grabbed window, in
- *				the same toplevel.
- *	    TK_GRAB_EXCLUDED -	there is a grab in effect; winPtr is
- *				outside the tree of the grab and is not
- *				an ancestor of the grabbed window in the
- *				same toplevel.
+ *	    TK_GRAB_IN_TREE -   there is a grab in effect, and winPtr is in
+ *				the grabbed subtree.
+ *	    TK_GRAB_ANCESTOR -  there is a grab in effect; winPtr is an
+ *				ancestor of the grabbed window, in the same
+ *				toplevel.
+ *	    TK_GRAB_EXCLUDED -	there is a grab in effect; winPtr is outside
+ *				the tree of the grab and is not an ancestor of
+ *				the grabbed window in the same toplevel.
  *
  * Side effects:
  *	None.
@@ -1581,8 +1553,8 @@ TkPositionInTree(winPtr, treePtr)
  */
 
 int
-TkGrabState(winPtr)
-    TkWindow *winPtr;		/* Window for which grab information is
+TkGrabState(
+    TkWindow *winPtr)		/* Window for which grab information is
 				 * needed. */
 {
     TkWindow *grabWinPtr = winPtr->dispPtr->grabWinPtr;
@@ -1597,3 +1569,11 @@ TkGrabState(winPtr)
 
     return TkPositionInTree(winPtr, grabWinPtr);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkMacWinMenu.c b/generic/tkMacWinMenu.c
index ca77c45..fa8dff6 100644
--- a/generic/tkMacWinMenu.c
+++ b/generic/tkMacWinMenu.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * tkMacWinMenu.c --
  *
  *	This module implements the common elements of the Mac and Windows
@@ -6,10 +6,10 @@
  *
  * Copyright (c) 1996-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: tkMacWinMenu.c,v 1.3 1999/04/16 01:51:19 stanton Exp $
+ * RCS: @(#) $Id: tkMacWinMenu.c,v 1.4 2005/11/14 22:44:11 dkf Exp $
  */
 
 #include "tkMenu.h"
@@ -19,9 +19,7 @@ typedef struct ThreadSpecificData {
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
-
-static int			PreprocessMenu _ANSI_ARGS_((TkMenu *menuPtr));
-
+static int		PreprocessMenu(TkMenu *menuPtr);
 
 /*
  *----------------------------------------------------------------------
@@ -31,8 +29,8 @@ static int			PreprocessMenu _ANSI_ARGS_((TkMenu *menuPtr));
  *	The guts of the preprocessing. Recursive.
  *
  * Results:
- *	The return value is a standard Tcl result (errors can occur
- *	while the postcommands are being processed).
+ *	The return value is a standard Tcl result (errors can occur while the
+ *	postcommands are being processed).
  *
  * Side effects:
  *	Since commands can get executed while this routine is being executed,
@@ -42,61 +40,59 @@ static int			PreprocessMenu _ANSI_ARGS_((TkMenu *menuPtr));
  */
 
 static int
-PreprocessMenu(menuPtr)
-    TkMenu *menuPtr;
+PreprocessMenu(
+    TkMenu *menuPtr)
 {
     int index, result, finished;
-    TkMenu *cascadeMenuPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
-   
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
     Tcl_Preserve((ClientData) menuPtr);
-    
+
     /*
      * First, let's process the post command on ourselves. If this command
      * destroys this menu, or if there was an error, we are done.
      */
-     
+
     result = TkPostCommand(menuPtr);
     if ((result != TCL_OK) || (menuPtr->tkwin == NULL)) {
-    	goto done;
+	goto done;
     }
-    
+
     /*
-     * Now, we go through structure and process all of the commands.
-     * Since the structure is changing, we stop after we do one command,
-     * and start over. When we get through without doing any, we are done.
+     * Now, we go through structure and process all of the commands. Since the
+     * structure is changing, we stop after we do one command, and start over.
+     * When we get through without doing any, we are done.
      */
-    
-    
+
     do {
-    	finished = 1;
-        for (index = 0; index < menuPtr->numEntries; index++) {
-            if ((menuPtr->entries[index]->type == CASCADE_ENTRY)
-            	    && (menuPtr->entries[index]->namePtr != NULL)) {
-            	if ((menuPtr->entries[index]->childMenuRefPtr != NULL)
-            		&& (menuPtr->entries[index]->childMenuRefPtr->menuPtr
-            		!= NULL)) {
-            	    cascadeMenuPtr =
-            	    	    menuPtr->entries[index]->childMenuRefPtr->menuPtr;
-            	    if (cascadeMenuPtr->postCommandGeneration != 
-            	    	    tsdPtr->postCommandGeneration) {
-            	    	cascadeMenuPtr->postCommandGeneration = 
-            	    		tsdPtr->postCommandGeneration;
-            	        result = PreprocessMenu(cascadeMenuPtr);
-            	        if (result != TCL_OK) {
-            	            goto done;
-            	        }
-            	        finished = 0;
-            	        break;
-            	    }
-            	}
-            }
-        }
+	finished = 1;
+	for (index = 0; index < menuPtr->numEntries; index++) {
+	    register TkMenuEntry *entryPtr = menuPtr->entries[index];
+
+	    if ((entryPtr->type == CASCADE_ENTRY)
+		    && (entryPtr->namePtr != NULL)
+		    && (entryPtr->childMenuRefPtr != NULL)
+		    && (entryPtr->childMenuRefPtr->menuPtr != NULL)) {
+		TkMenu *cascadeMenuPtr = entryPtr->childMenuRefPtr->menuPtr;
+
+		if (cascadeMenuPtr->postCommandGeneration !=
+			tsdPtr->postCommandGeneration) {
+		    cascadeMenuPtr->postCommandGeneration =
+			    tsdPtr->postCommandGeneration;
+		    result = PreprocessMenu(cascadeMenuPtr);
+		    if (result != TCL_OK) {
+			goto done;
+		    }
+		    finished = 0;
+		    break;
+		}
+	    }
+	}
     } while (!finished);
-    
-    done:
-    Tcl_Release((ClientData)menuPtr);
+
+  done:
+    Tcl_Release((ClientData) menuPtr);
     return result;
 }
 
@@ -105,23 +101,23 @@ PreprocessMenu(menuPtr)
  *
  * TkPreprocessMenu --
  *
- *	On the Mac and on Windows, all of the postcommand processing has
- *	to be done on the entire tree underneath the main window to be
- *	posted. This means that we have to traverse the menu tree and
- *	issue the postcommands for all of the menus that have cascades
- *	attached. Since the postcommands can change the menu structure while
- *	we are traversing, we have to be extremely careful. Basically, the
- *	idea is to traverse the structure until we succesfully process
- *	one postcommand. Then we start over, and do it again until
- *	we traverse the whole structure without processing any postcommands.
+ *	On the Mac and on Windows, all of the postcommand processing has to be
+ *	done on the entire tree underneath the main window to be posted. This
+ *	means that we have to traverse the menu tree and issue the
+ *	postcommands for all of the menus that have cascades attached. Since
+ *	the postcommands can change the menu structure while we are
+ *	traversing, we have to be extremely careful. Basically, the idea is to
+ *	traverse the structure until we succesfully process one postcommand.
+ *	Then we start over, and do it again until we traverse the whole
+ *	structure without processing any postcommands.
  *
- *	We are also going to set up the cascade back pointers in here
- *	since we have to traverse the entire structure underneath the menu
- *	anyway, We can clear the postcommand marks while we do that.
+ *	We are also going to set up the cascade back pointers in here since we
+ *	have to traverse the entire structure underneath the menu anyway. We
+ *	can clear the postcommand marks while we do that.
  *
  * Results:
- *	The return value is a standard Tcl result (errors can occur
- *	while the postcommands are being processed).
+ *	The return value is a standard Tcl result (errors can occur while the
+ *	postcommands are being processed).
  *
  * Side effects:
  *	Since commands can get executed while this routine is being executed,
@@ -131,13 +127,21 @@ PreprocessMenu(menuPtr)
  */
 
 int
-TkPreprocessMenu(menuPtr)
-    TkMenu *menuPtr;
+TkPreprocessMenu(
+    TkMenu *menuPtr)
 {
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
-            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     tsdPtr->postCommandGeneration++;
     menuPtr->postCommandGeneration = tsdPtr->postCommandGeneration;
     return PreprocessMenu(menuPtr);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkMenu.h b/generic/tkMenu.h
index dc23478..630e748 100644
--- a/generic/tkMenu.h
+++ b/generic/tkMenu.h
@@ -1,14 +1,15 @@
 /*
  * tkMenu.h --
  *
- *	Declarations shared among all of the files that implement menu widgets.
+ *	Declarations shared among all of the files that implement menu
+ *	widgets.
  *
  * Copyright (c) 1996-1998 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: tkMenu.h,v 1.9 2005/10/12 09:43:37 dkf Exp $
+ * RCS: @(#) $Id: tkMenu.h,v 1.10 2005/11/14 22:44:11 dkf Exp $
  */
 
 #ifndef _TKMENU
@@ -39,26 +40,28 @@ typedef struct TkMenuPlatformData_ *TkMenuPlatformData;
 typedef struct TkMenuPlatformEntryData_ *TkMenuPlatformEntryData;
 
 /*
- * Legal values for the "compound" field of TkMenuEntry and TkMenuButton records.
+ * Legal values for the "compound" field of TkMenuEntry and TkMenuButton
+ * records.
  */
 
 enum compound {
     COMPOUND_BOTTOM, COMPOUND_CENTER, COMPOUND_LEFT, COMPOUND_NONE,
-	COMPOUND_RIGHT, COMPOUND_TOP
+    COMPOUND_RIGHT, COMPOUND_TOP
 };
 
 /*
- * One of the following data structures is kept for each entry of each
- * menu managed by this file:
+ * One of the following data structures is kept for each entry of each menu
+ * managed by this file:
  */
 
 typedef struct TkMenuEntry {
-    int type;			/* Type of menu entry;  see below for
-				 * valid types. */
-    struct TkMenu *menuPtr;	/* Menu with which this entry is associated. */
+    int type;			/* Type of menu entry; see below for valid
+				 * types. */
+    struct TkMenu *menuPtr;	/* Menu with which this entry is
+				 * associated. */
     Tk_OptionTable optionTable;	/* Option table for this menu entry. */
-    Tcl_Obj *labelPtr;		/* Main text label displayed in entry (NULL
-				 * if no label). */
+    Tcl_Obj *labelPtr;		/* Main text label displayed in entry (NULL if
+				 * no label). */
     int labelLength;		/* Number of non-NULL characters in label. */
     int state;			/* State of button for display purposes:
 				 * normal, active, or disabled. */
@@ -68,19 +71,18 @@ typedef struct TkMenuEntry {
     Tcl_Obj *underlinePtr;	/* Index of character to underline. */
     Tcl_Obj *bitmapPtr;		/* Bitmap to display in menu entry, or None.
 				 * If not None then label is ignored. */
-    Tcl_Obj *imagePtr;		/* Name of image to display, or
-				 * NULL.  If non-NULL, bitmap, text, and
-				 * textVarName are ignored. */
+    Tcl_Obj *imagePtr;		/* Name of image to display, or NULL. If not
+				 * NULL, bitmap, text, and textVarName are
+				 * ignored. */
     Tk_Image image;		/* Image to display in menu entry, or NULL if
 				 * none. */
-    Tcl_Obj *selectImagePtr;	/* Name of image to display when selected, or 
+    Tcl_Obj *selectImagePtr;	/* Name of image to display when selected, or
 				 * NULL. */
-    Tk_Image selectImage;	/* Image to display in entry when selected,
-				 * or NULL if none.  Ignored if image is
-				 * NULL. */
-    Tcl_Obj *accelPtr;		/* Accelerator string displayed at right
-				 * of menu entry.  NULL means no such
-				 * accelerator.  Malloc'ed. */
+    Tk_Image selectImage;	/* Image to display in entry when selected, or
+				 * NULL if none. Ignored if image is NULL. */
+    Tcl_Obj *accelPtr;		/* Accelerator string displayed at right of
+				 * menu entry. NULL means no such accelerator.
+				 * Malloc'ed. */
     int accelLength;		/* Number of non-NULL characters in
 				 * accelerator. */
     int indicatorOn;		/* True means draw indicator, false means
@@ -91,42 +93,43 @@ typedef struct TkMenuEntry {
      */
 
     Tcl_Obj *borderPtr;		/* Structure used to draw background for
-				 * entry.  NULL means use overall border
-				 * for menu. */
-    Tcl_Obj *fgPtr;		/* Foreground color to use for entry.  NULL
+				 * entry. NULL means use overall border for
+				 * menu. */
+    Tcl_Obj *fgPtr;		/* Foreground color to use for entry. NULL
 				 * means use foreground color from menu. */
     Tcl_Obj *activeBorderPtr;	/* Used to draw background and border when
-				 * element is active.  NULL means use
+				 * element is active. NULL means use
 				 * activeBorder from menu. */
     Tcl_Obj *activeFgPtr;	/* Foreground color to use when entry is
-				 * active.  NULL means use active foreground
+				 * active. NULL means use active foreground
 				 * from menu. */
     Tcl_Obj *indicatorFgPtr;	/* Color for indicators in radio and check
-				 * button entries.  NULL means use indicatorFg
+				 * button entries. NULL means use indicatorFg
 				 * GC from menu. */
-    Tcl_Obj *fontPtr;		/* Text font for menu entries.  NULL means
-				 * use overall font for menu. */
-    int columnBreak;		/* If this is 0, this item appears below
-				 * the item in front of it. If this is
-				 * 1, this item starts a new column. This
-				 * field is always 0 for tearoff and separator
+    Tcl_Obj *fontPtr;		/* Text font for menu entries. NULL means use
+				 * overall font for menu. */
+    int columnBreak;		/* If this is 0, this item appears below the
+				 * item in front of it. If this is 1, this
+				 * item starts a new column. This field is
+				 * always 0 for tearoff and separator
 				 * entries. */
     int hideMargin;		/* If this is 0, then the item has enough
     				 * margin to accomodate a standard check mark
     				 * and a default right margin. If this is 1,
-    				 * then the item has no such margins.  and
+    				 * then the item has no such margins, and
     				 * checkbuttons and radiobuttons with this set
-    				 * will have a rectangle drawn in the indicator
-    				 * around the item if the item is checked. This
-    				 * is useful for palette menus.  This field is
-    				 * ignored for separators and tearoffs. */
+    				 * will have a rectangle drawn in the
+    				 * indicator around the item if the item is
+    				 * checked. This is useful for palette menus.
+    				 * This field is ignored for separators and
+    				 * tearoffs. */
     int indicatorSpace;		/* The width of the indicator space for this
 				 * entry. */
     int labelWidth;		/* Number of pixels to allow for displaying
 				 * labels in menu entries. */
-    int compound;		/* Value of -compound option; specifies whether
-				 * the entry should show both an image and
-				 * text, and, if so, how. */
+    int compound;		/* Value of -compound option; specifies
+				 * whether the entry should show both an image
+				 * and text, and, if so, how. */
 
     /*
      * Information used to implement this entry's action:
@@ -143,19 +146,19 @@ typedef struct TkMenuEntry {
     Tcl_Obj *offValuePtr;	/* Value to store in variable when not
 				 * selected (only for check buttons).
 				 * Malloc'ed. */
-    
+
     /*
      * Information used for drawing this menu entry.
      */
-     
+
     int width;			/* Number of pixels occupied by entry in
-				 * horizontal dimension. Not used except
-				 * in menubars. The width of norma menus
-				 * is dependent on the rest of the menu. */
+				 * horizontal dimension. Not used except in
+				 * menubars. The width of norma menus is
+				 * dependent on the rest of the menu. */
     int x;			/* X-coordinate of leftmost pixel in entry */
     int height;			/* Number of pixels occupied by entry in
-				 * vertical dimension, including raised
-				 * border drawn around entry when active. */
+				 * vertical dimension, including raised border
+				 * drawn around entry when active. */
     int y;			/* Y-coordinate of topmost pixel in entry. */
     GC textGC;			/* GC for drawing text in entry.  NULL means
 				 * use overall textGC for menu. */
@@ -163,51 +166,49 @@ typedef struct TkMenuEntry {
 				 * NULL means use overall activeGC for
 				 * menu. */
     GC disabledGC;		/* Used to produce disabled effect for entry.
-				 * NULL means use overall disabledGC from
-				 * menu structure.  See comments for
-				 * disabledFg in menu structure for more
-				 * information. */
-    GC indicatorGC;		/* For drawing indicators.  None means use
-				 * GC from menu. */
+				 * NULL means use overall disabledGC from menu
+				 * structure.  See comments for disabledFg in
+				 * menu structure for more information. */
+    GC indicatorGC;		/* For drawing indicators. None means use GC
+				 * from menu. */
 
     /*
      * Miscellaneous fields.
      */
- 
-    int entryFlags;		/* Various flags.  See below for
-				   definitions. */
-    int index;			/* Need to know which index we are. This
-    				 * is zero-based. This is the top-left entry
-    				 * of the menu. */
-				 
+
+    int entryFlags;		/* Various flags. See below for
+				 * definitions. */
+    int index;			/* Need to know which index we are. This is
+    				 * zero-based. This is the top-left entry of
+    				 * the menu. */
+
     /*
      * Bookeeping for master menus and cascade menus.
      */
-     
+
     struct TkMenuReferences *childMenuRefPtr;
-    				/* A pointer to the hash table entry for
-    				 * the child menu. Stored here when the menu
-    				 * entry is configured so that a hash lookup
-    				 * is not necessary later.*/
+    				/* A pointer to the hash table entry for the
+    				 * child menu. Stored here when the menu entry
+    				 * is configured so that a hash lookup is not
+    				 * necessary later.*/
     struct TkMenuEntry *nextCascadePtr;
     				/* The next cascade entry that is a parent of
-    				 * this entry's child cascade menu. NULL
-    				 * end of list, this is not a cascade entry,
-    				 * or the menu that this entry point to
-    				 * does not yet exist. */
+    				 * this entry's child cascade menu. NULL end
+    				 * of list, this is not a cascade entry, or
+    				 * the menu that this entry point to does not
+    				 * yet exist. */
     TkMenuPlatformEntryData platformEntryData;
     				/* The data for the specific type of menu.
-				 * Depends on platform and menu type what
-  				 * kind of options are in this structure.
-  				 */
+				 * Depends on platform and menu type what kind
+				 * of options are in this structure. */
 } TkMenuEntry;
 
 /*
  * Flag values defined for menu entries:
  *
- * ENTRY_SELECTED:		Non-zero means this is a radio or check
- *				button and that it should be drawn in
- *				the "selected" state.
+ * ENTRY_SELECTED:		Non-zero means this is a radio or check button
+ *				and that it should be drawn in the "selected"
+ *				state.
  * ENTRY_NEEDS_REDISPLAY:	Non-zero means the entry should be redisplayed.
  * ENTRY_LAST_COLUMN:		Used by the drawing code. If the entry is in
  *				the last column, the space to its right needs
@@ -247,37 +248,36 @@ EXTERN char *tkMenuStateStrings[];
 #define ENTRY_DISABLED 2
 
 /*
- * A data structure of the following type is kept for each
- * menu widget:
+ * A data structure of the following type is kept for each menu widget:
  */
 
 typedef struct TkMenu {
-    Tk_Window tkwin;		/* Window that embodies the pane.  NULL
-				 * means that the window has been destroyed
-				 * but the data structures haven't yet been
-				 * cleaned up.*/
-    Display *display;		/* Display containing widget.  Needed, among
+    Tk_Window tkwin;		/* Window that embodies the pane. NULL means
+				 * that the window has been destroyed but the
+				 * data structures haven't yet been cleaned
+				 * up. */
+    Display *display;		/* Display containing widget. Needed, among
 				 * other things, so that resources can be
 				 * freed up even after tkwin has gone away. */
     Tcl_Interp *interp;		/* Interpreter associated with menu. */
     Tcl_Command widgetCmd;	/* Token for menu's widget command. */
-    TkMenuEntry **entries;	/* Array of pointers to all the entries
-				 * in the menu.  NULL means no entries. */
+    TkMenuEntry **entries;	/* Array of pointers to all the entries in the
+				 * menu. NULL means no entries. */
     int numEntries;		/* Number of elements in entries. */
-    int active;			/* Index of active entry.  -1 means
-				 * nothing active. */
-    int menuType;		/* MASTER_MENU, TEAROFF_MENU, or MENUBAR.
-    				 * See below for definitions. */
-    Tcl_Obj *menuTypePtr;	/* Used to control whether created tkwin
-				 * is a toplevel or not. "normal", "menubar",
-				 * or "toplevel" */
+    int active;			/* Index of active entry. -1 means nothing
+				 * active. */
+    int menuType;		/* MASTER_MENU, TEAROFF_MENU, or MENUBAR. See
+    				 * below for definitions. */
+    Tcl_Obj *menuTypePtr;	/* Used to control whether created tkwin is a
+				 * toplevel or not. "normal", "menubar", or
+				 * "toplevel" */
 
     /*
      * Information used when displaying widget:
      */
 
-    Tcl_Obj *borderPtr;		/* Structure used to draw 3-D
-				 * border and background for menu. */
+    Tcl_Obj *borderPtr;		/* Structure used to draw 3-D border and
+				 * background for menu. */
     Tcl_Obj *borderWidthPtr;	/* Width of border around whole menu. */
     Tcl_Obj *activeBorderPtr;	/* Used to draw background and border for
 				 * active element (if any). */
@@ -286,18 +286,17 @@ typedef struct TkMenu {
     Tcl_Obj *reliefPtr;		/* 3-d effect: TK_RELIEF_RAISED, etc. */
     Tcl_Obj *fontPtr;		/* Text font for menu entries. */
     Tcl_Obj *fgPtr;		/* Foreground color for entries. */
-    Tcl_Obj *disabledFgPtr;	/* Foreground color when disabled.  NULL
-				 * means use normalFg with a 50% stipple
-				 * instead. */
+    Tcl_Obj *disabledFgPtr;	/* Foreground color when disabled. NULL means
+				 * use normalFg with a 50% stipple instead. */
     Tcl_Obj *activeFgPtr;	/* Foreground color for active entry. */
     Tcl_Obj *indicatorFgPtr;	/* Color for indicators in radio and check
 				 * button entries. */
-    Pixmap gray;		/* Bitmap for drawing disabled entries in
-				 * a stippled fashion.  None means not
-				 * allocated yet. */
-    GC textGC;			/* GC for drawing text and other features
-				 * of menu entries. */
-    GC disabledGC;		/* Used to produce disabled effect.  If
+    Pixmap gray;		/* Bitmap for drawing disabled entries in a
+				 * stippled fashion. None means not allocated
+				 * yet. */
+    GC textGC;			/* GC for drawing text and other features of
+				 * menu entries. */
+    GC disabledGC;		/* Used to produce disabled effect. If
 				 * disabledFg isn't NULL, this GC is used to
 				 * draw text and icons for disabled entries.
 				 * Otherwise text and icons are drawn with
@@ -305,44 +304,43 @@ typedef struct TkMenu {
 				 * background across them. */
     GC activeGC;		/* GC for drawing active entry. */
     GC indicatorGC;		/* For drawing indicators. */
-    GC disabledImageGC;		/* Used for drawing disabled images. They
-				 * have to be stippled. This is created
-				 * when the image is about to be drawn the
-				 * first time. */
+    GC disabledImageGC;		/* Used for drawing disabled images. They have
+				 * to be stippled. This is created when the
+				 * image is about to be drawn the first
+				 * time. */
 
     /*
      * Information about geometry of menu.
      */
-    
+
     int totalWidth;		/* Width of entire menu */
     int totalHeight;		/* Height of entire menu */
-   
+
     /*
      * Miscellaneous information:
      */
 
     int tearoff;		/* 1 means this menu can be torn off. On some
-    				 * platforms, the user can drag an outline
-    				 * of the menu by just dragging outside of
-    				 * the menu, and the tearoff is created where
-    				 * the mouse is released. On others, an
-				 * indicator (such as a dashed stripe) is
-				 * drawn, and when the menu is selected, the
-				 * tearoff is created. */
+    				 * platforms, the user can drag an outline of
+    				 * the menu by just dragging outside of the
+    				 * menu, and the tearoff is created where the
+    				 * mouse is released. On others, an indicator
+    				 * (such as a dashed stripe) is drawn, and
+    				 * when the menu is selected, the tearoff is
+    				 * created. */
     Tcl_Obj *titlePtr;		/* The title to use when this menu is torn
-    				 * off. If this is NULL, a default scheme
-    				 * will be used to generate a title for
-    				 * tearoff. */
-    Tcl_Obj *tearoffCommandPtr;	/* If non-NULL, points to a command to
-				 * run whenever the menu is torn-off. */
-    Tcl_Obj *takeFocusPtr;	/* Value of -takefocus option;  not used in
-				 * the C code, but used by keyboard traversal
+    				 * off. If this is NULL, a default scheme will
+    				 * be used to generate a title for tearoff. */
+    Tcl_Obj *tearoffCommandPtr;	/* If non-NULL, points to a command to run
+				 * whenever the menu is torn-off. */
+    Tcl_Obj *takeFocusPtr;	/* Value of -takefocus option; not used in the
+				 * C code, but used by keyboard traversal
 				 * scripts.  Malloc'ed, but may be NULL. */
     Tcl_Obj *cursorPtr;		/* Current cursor for window, or None. */
     Tcl_Obj *postCommandPtr;	/* Used to detect cycles in cascade hierarchy
-    				 * trees when preprocessing postcommands
-    				 * on some platforms. See PostMenu for
-    				 * more details. */
+    				 * trees when preprocessing postcommands on
+    				 * some platforms. See PostMenu for more
+    				 * details. */
     int postCommandGeneration;	/* Need to do pre-invocation post command
 				 * traversal */
     int menuFlags;		/* Flags for use by X; see below for
@@ -350,7 +348,7 @@ typedef struct TkMenu {
     TkMenuEntry *postedCascade;	/* Points to menu entry for cascaded submenu
 				 * that is currently posted or NULL if no
 				 * submenu posted. */
-    struct TkMenu *nextInstancePtr;	
+    struct TkMenu *nextInstancePtr;
     				/* The next instance of this menu in the
     				 * chain. */
     struct TkMenu *masterMenuPtr;
@@ -358,29 +356,26 @@ typedef struct TkMenu {
     				 * clone chain. Points back to this structure
     				 * if this menu is a master menu. */
     struct TkMenuOptionTables *optionTablesPtr;
-				/* A pointer to the collection of option tables
-				 * that work with menus and menu entries. */
+				/* A pointer to the collection of option
+				 * tables that work with menus and menu
+				 * entries. */
     Tk_Window parentTopLevelPtr;/* If this menu is a menubar, this is the
-    				 * toplevel that owns the menu. Only applicable
-    				 * for menubar clones.
-    				 */
-    struct TkMenuReferences *menuRefPtr;	
+    				 * toplevel that owns the menu. Only
+    				 * applicable for menubar clones. */
+    struct TkMenuReferences *menuRefPtr;
     				/* Each menu is hashed into a table with the
-    				 * name of the menu's window as the key.
-    				 * The information in this hash table includes
-    				 * a pointer to the menu (so that cascades
-    				 * can find this menu), a pointer to the
-    				 * list of toplevel widgets that have this
-    				 * menu as its menubar, and a list of menu
-    				 * entries that have this menu specified
-    				 * as a cascade. */    
+    				 * name of the menu's window as the key. The
+    				 * information in this hash table includes a
+    				 * pointer to the menu (so that cascades can
+    				 * find this menu), a pointer to the list of
+    				 * toplevel widgets that have this menu as its
+    				 * menubar, and a list of menu entries that
+    				 * have this menu specified as a cascade. */
     TkMenuPlatformData platformData;
 				/* The data for the specific type of menu.
-  				 * Depends on platform and menu type what
-  				 * kind of options are in this structure.
-  				 */
-    Tk_OptionSpec *extensionPtr;
-				/* Needed by the configuration package for
+  				 * Depends on platform and menu type what kind
+  				 * of options are in this structure. */
+    Tk_OptionSpec *extensionPtr;/* Needed by the configuration package for
 				 * this widget to be extended. */
     Tk_SavedOptions *errorStructPtr;
 				/* We actually have to allocate these because
@@ -390,8 +385,8 @@ typedef struct TkMenu {
 
 /*
  * When the toplevel configure -menu command is executed, the menu may not
- * exist yet. We need to keep a linked list of windows that reference
- * a particular menu.
+ * exist yet. We need to keep a linked list of windows that reference a
+ * particular menu.
  */
 
 typedef struct TkMenuTopLevelList {
@@ -402,61 +397,60 @@ typedef struct TkMenuTopLevelList {
 } TkMenuTopLevelList;
 
 /*
- * The following structure is used to keep track of things which
- * reference a menu. It is created when:
+ * The following structure is used to keep track of things which reference a
+ * menu. It is created when:
  * - a menu is created.
  * - a cascade entry is added to a menu with a non-null name
- * - the "-menu" configuration option is used on a toplevel widget
- * with a non-null parameter.
+ * - the "-menu" configuration option is used on a toplevel widget with a
+ *   non-null parameter.
  *
- * One of these three fields must be non-NULL, but any of the fields may
- * be NULL. This structure makes it easy to determine whether or not
- * anything like recalculating platform data or geometry is necessary
- * when one of the three actions above is performed.
+ * One of these three fields must be non-NULL, but any of the fields may be
+ * NULL. This structure makes it easy to determine whether or not anything
+ * like recalculating platform data or geometry is necessary when one of the
+ * three actions above is performed.
  */
 
 typedef struct TkMenuReferences {
-    struct TkMenu *menuPtr;	/* The menu data structure. This is NULL
-    				 * if the menu does not exist. */
+    struct TkMenu *menuPtr;	/* The menu data structure. This is NULL if
+    				 * the menu does not exist. */
     TkMenuTopLevelList *topLevelListPtr;
-    				/* First in the list of all toplevels that 
-    				 * have this menu as its menubar. NULL if no 
+    				/* First in the list of all toplevels that
+    				 * have this menu as its menubar. NULL if no
     				 * toplevel widgets have this menu as its
     				 * menubar. */
-    TkMenuEntry *parentEntryPtr;/* First in the list of all cascade menu 
+    TkMenuEntry *parentEntryPtr;/* First in the list of all cascade menu
     				 * entries that have this menu as their child.
     				 * NULL means no cascade entries. */
     Tcl_HashEntry *hashEntryPtr;/* This is needed because the pathname of the
     				 * window (which is what we hash on) may not
-    				 * be around when we are deleting.
-    				 */
+    				 * be around when we are deleting. */
 } TkMenuReferences;
 
 /*
- * This structure contains all of the option tables that are needed
- * by menus.
+ * This structure contains all of the option tables that are needed by menus.
  */
 
 typedef struct TkMenuOptionTables {
-    Tk_OptionTable menuOptionTable;	/* The option table for menus. */
-    Tk_OptionTable entryOptionTables[6];/* The tables for menu entries. */
+    Tk_OptionTable menuOptionTable;
+				/* The option table for menus. */
+    Tk_OptionTable entryOptionTables[6];
+				/* The tables for menu entries. */
 } TkMenuOptionTables;
 
 /*
  * Flag bits for menus:
  *
- * REDRAW_PENDING:		Non-zero means a DoWhenIdle handler
- *				has already been queued to redraw
- *				this window.
+ * REDRAW_PENDING:		Non-zero means a DoWhenIdle handler has
+ *				already been queued to redraw this window.
  * RESIZE_PENDING:		Non-zero means a call to ComputeMenuGeometry
  *				has already been scheduled.
- * MENU_DELETION_PENDING	Non-zero means that we are currently destroying
- *				this menu's internal structures. This is useful 
- *				when we are in the middle of cleaning
- *				this master menu's chain of menus up when
- *				TkDestroyMenu was called again on this
+ * MENU_DELETION_PENDING	Non-zero means that we are currently
+ *				destroying this menu's internal structures.
+ *				This is useful when we are in the middle of
+ *				cleaning this master menu's chain of menus up
+ *				when TkDestroyMenu was called again on this
  *				menu (via a destroy binding or somesuch).
- * MENU_WIN_DESTRUCTION_PENDING Non-zero means we are in the middle of 
+ * MENU_WIN_DESTRUCTION_PENDING Non-zero means we are in the middle of
  *                              destroying this menu's Tk_Window.
  * MENU_PLATFORM_FLAG1...	Reserved for use by the platform-specific menu
  *				code.
@@ -471,14 +465,14 @@ typedef struct TkMenuOptionTables {
 #define MENU_PLATFORM_FLAG3	(1 << 28)
 
 /*
- * Each menu created by the user is a MASTER_MENU. When a menu is torn off,
- * a TEAROFF_MENU instance is created. When a menu is assigned to a toplevel
- * as a menu bar, a MENUBAR instance is created. All instances have the same
+ * Each menu created by the user is a MASTER_MENU. When a menu is torn off, a
+ * TEAROFF_MENU instance is created. When a menu is assigned to a toplevel as
+ * a menu bar, a MENUBAR instance is created. All instances have the same
  * configuration information. If the master instance is deleted, all instances
  * are deleted. If one of the other instances is deleted, only that instance
  * is deleted.
  */
- 
+
 #define UNKNOWN_TYPE		-1
 #define MASTER_MENU 		0
 #define TEAROFF_MENU 		1
@@ -493,93 +487,74 @@ typedef struct TkMenuOptionTables {
 #define DECORATION_BORDER_WIDTH 2
 
 /*
- * Menu-related procedures that are shared among Tk modules but not exported
- * to the outside world:
+ * Menu-related functions that are shared among Tk modules but not exported to
+ * the outside world:
  */
 
-EXTERN int		TkActivateMenuEntry _ANSI_ARGS_((TkMenu *menuPtr,
-			    int index));
-EXTERN void		TkBindMenu _ANSI_ARGS_((
-			    Tk_Window tkwin, TkMenu *menuPtr));
-EXTERN TkMenuReferences *
-			TkCreateMenuReferences _ANSI_ARGS_((Tcl_Interp *interp,
-			    char *name));
-EXTERN void		TkDestroyMenu _ANSI_ARGS_((TkMenu *menuPtr));
-EXTERN void             TkEventuallyRecomputeMenu _ANSI_ARGS_((
-			    TkMenu *menuPtr));
-EXTERN void		TkEventuallyRedrawMenu _ANSI_ARGS_((
-    			    TkMenu *menuPtr, TkMenuEntry *mePtr));
-EXTERN TkMenuReferences *
-			TkFindMenuReferences _ANSI_ARGS_((Tcl_Interp *interp,
-			    char *name));
-EXTERN TkMenuReferences *
-			TkFindMenuReferencesObj _ANSI_ARGS_((
-			    Tcl_Interp *interp, Tcl_Obj *namePtr));
-EXTERN int		TkFreeMenuReferences _ANSI_ARGS_((
-			    TkMenuReferences *menuRefPtr));
-EXTERN Tcl_HashTable *	TkGetMenuHashTable _ANSI_ARGS_((Tcl_Interp *interp));
-EXTERN int		TkGetMenuIndex _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkMenu *menuPtr, Tcl_Obj *objPtr, int lastOK,
-			    int *indexPtr));
-EXTERN void		TkMenuInitializeDrawingFields _ANSI_ARGS_((
-			    TkMenu *menuPtr));
-EXTERN void		TkMenuInitializeEntryDrawingFields _ANSI_ARGS_((
-			    TkMenuEntry *mePtr));
-EXTERN int		TkInvokeMenu _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkMenu *menuPtr, int index));
-EXTERN void		TkMenuConfigureDrawOptions _ANSI_ARGS_((
-			    TkMenu *menuPtr));
-EXTERN int		TkMenuConfigureEntryDrawOptions _ANSI_ARGS_((
-			    TkMenuEntry *mePtr, int index));
-EXTERN void		TkMenuFreeDrawOptions _ANSI_ARGS_((TkMenu *menuPtr));
-EXTERN void		TkMenuEntryFreeDrawOptions _ANSI_ARGS_((
-			    TkMenuEntry *mePtr));
-EXTERN void		TkMenuEventProc _ANSI_ARGS_((ClientData clientData,
-    			    XEvent *eventPtr));
-EXTERN void		TkMenuImageProc _ANSI_ARGS_((
-    			    ClientData clientData, int x, int y, int width,
-			    int height, int imgWidth, int imgHeight));
-EXTERN void		TkMenuInit _ANSI_ARGS_((void));
-EXTERN void		TkMenuSelectImageProc _ANSI_ARGS_
-			    ((ClientData clientData, int x, int y,
+EXTERN int		TkActivateMenuEntry(TkMenu *menuPtr, int index);
+EXTERN void		TkBindMenu(Tk_Window tkwin, TkMenu *menuPtr);
+EXTERN TkMenuReferences*TkCreateMenuReferences(Tcl_Interp *interp,
+			    char *name);
+EXTERN void		TkDestroyMenu(TkMenu *menuPtr);
+EXTERN void             TkEventuallyRecomputeMenu(TkMenu *menuPtr);
+EXTERN void		TkEventuallyRedrawMenu(TkMenu *menuPtr,
+			    TkMenuEntry *mePtr);
+EXTERN TkMenuReferences*TkFindMenuReferences(Tcl_Interp *interp, char *name);
+EXTERN TkMenuReferences*TkFindMenuReferencesObj(Tcl_Interp *interp,
+			    Tcl_Obj *namePtr);
+EXTERN int		TkFreeMenuReferences(TkMenuReferences *menuRefPtr);
+EXTERN Tcl_HashTable *	TkGetMenuHashTable(Tcl_Interp *interp);
+EXTERN int		TkGetMenuIndex(Tcl_Interp *interp, TkMenu *menuPtr,
+			    Tcl_Obj *objPtr, int lastOK, int *indexPtr);
+EXTERN void		TkMenuInitializeDrawingFields(TkMenu *menuPtr);
+EXTERN void		TkMenuInitializeEntryDrawingFields(TkMenuEntry *mePtr);
+EXTERN int		TkInvokeMenu(Tcl_Interp *interp, TkMenu *menuPtr,
+			    int index);
+EXTERN void		TkMenuConfigureDrawOptions(TkMenu *menuPtr);
+EXTERN int		TkMenuConfigureEntryDrawOptions(
+			    TkMenuEntry *mePtr, int index);
+EXTERN void		TkMenuFreeDrawOptions(TkMenu *menuPtr);
+EXTERN void		TkMenuEntryFreeDrawOptions(TkMenuEntry *mePtr);
+EXTERN void		TkMenuEventProc(ClientData clientData,
+    			    XEvent *eventPtr);
+EXTERN void		TkMenuImageProc(ClientData clientData, int x, int y,
 			    int width, int height, int imgWidth,
-			    int imgHeight));
-EXTERN Tcl_Obj *	TkNewMenuName _ANSI_ARGS_((Tcl_Interp *interp, 
-			    Tcl_Obj *parentNamePtr, TkMenu *menuPtr));
-EXTERN int		TkPostCommand _ANSI_ARGS_((TkMenu *menuPtr));
-EXTERN int		TkPostSubmenu _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkMenu *menuPtr, TkMenuEntry *mePtr));
-EXTERN int		TkPostTearoffMenu _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkMenu *menuPtr, int x, int y));
-EXTERN int		TkPreprocessMenu _ANSI_ARGS_((TkMenu *menuPtr));
-EXTERN void             TkRecomputeMenu _ANSI_ARGS_((TkMenu *menuPtr));
+			    int imgHeight);
+EXTERN void		TkMenuInit(void);
+EXTERN void		TkMenuSelectImageProc(ClientData clientData, int x,
+			    int y, int width, int height, int imgWidth,
+			    int imgHeight);
+EXTERN Tcl_Obj *	TkNewMenuName(Tcl_Interp *interp,
+			    Tcl_Obj *parentNamePtr, TkMenu *menuPtr);
+EXTERN int		TkPostCommand(TkMenu *menuPtr);
+EXTERN int		TkPostSubmenu(Tcl_Interp *interp, TkMenu *menuPtr,
+			    TkMenuEntry *mePtr);
+EXTERN int		TkPostTearoffMenu(Tcl_Interp *interp, TkMenu *menuPtr,
+			    int x, int y);
+EXTERN int		TkPreprocessMenu(TkMenu *menuPtr);
+EXTERN void             TkRecomputeMenu(TkMenu *menuPtr);
 
 /*
- * These routines are the platform-dependent routines called by the
- * common code.
+ * These routines are the platform-dependent routines called by the common
+ * code.
  */
 
-EXTERN void		TkpComputeMenubarGeometry _ANSI_ARGS_((
-			    TkMenu *menuPtr));
-EXTERN void		TkpComputeStandardMenuGeometry _ANSI_ARGS_
-			    ((TkMenu *menuPtr));
-EXTERN int		TkpConfigureMenuEntry
-                            _ANSI_ARGS_((TkMenuEntry *mePtr));
-EXTERN void		TkpDestroyMenu _ANSI_ARGS_((TkMenu *menuPtr));
-EXTERN void		TkpDestroyMenuEntry
-			    _ANSI_ARGS_((TkMenuEntry *mEntryPtr));
-EXTERN void		TkpDrawMenuEntry _ANSI_ARGS_((TkMenuEntry *mePtr,
-			    Drawable d, Tk_Font tkfont, 
+EXTERN void		TkpComputeMenubarGeometry(TkMenu *menuPtr);
+EXTERN void		TkpComputeStandardMenuGeometry(TkMenu *menuPtr);
+EXTERN int		TkpConfigureMenuEntry(TkMenuEntry *mePtr);
+EXTERN void		TkpDestroyMenu(TkMenu *menuPtr);
+EXTERN void		TkpDestroyMenuEntry(TkMenuEntry *mEntryPtr);
+EXTERN void		TkpDrawMenuEntry(TkMenuEntry *mePtr,
+			    Drawable d, Tk_Font tkfont,
 			    CONST Tk_FontMetrics *menuMetricsPtr, int x,
 			    int y, int width, int height, int strictMotif,
-			    int drawArrow));
-EXTERN void		TkpMenuInit _ANSI_ARGS_((void));
-EXTERN int		TkpMenuNewEntry _ANSI_ARGS_((TkMenuEntry *mePtr));
-EXTERN int		TkpNewMenu _ANSI_ARGS_((TkMenu *menuPtr));
-EXTERN int		TkpPostMenu _ANSI_ARGS_((Tcl_Interp *interp,
-			    TkMenu *menuPtr, int x, int y));
-EXTERN void		TkpSetWindowMenuBar _ANSI_ARGS_((Tk_Window tkwin,
-			    TkMenu *menuPtr));
+			    int drawArrow);
+EXTERN void		TkpMenuInit(void);
+EXTERN int		TkpMenuNewEntry(TkMenuEntry *mePtr);
+EXTERN int		TkpNewMenu(TkMenu *menuPtr);
+EXTERN int		TkpPostMenu(Tcl_Interp *interp, TkMenu *menuPtr,
+			    int x, int y);
+EXTERN void		TkpSetWindowMenuBar(Tk_Window tkwin, TkMenu *menuPtr);
 
 # undef TCL_STORAGE_CLASS
 # define TCL_STORAGE_CLASS DLLIMPORT
diff --git a/generic/tkMessage.c b/generic/tkMessage.c
index b32ecfc..eb4974d 100644
--- a/generic/tkMessage.c
+++ b/generic/tkMessage.c
@@ -1,18 +1,18 @@
-/* 
+/*
  * tkMessage.c --
  *
- *	This module implements a message widgets for the Tk
- *	toolkit.  A message widget displays a multi-line string
- *	in a window according to a particular aspect ratio.
+ *	This module implements a message widgets for the Tk toolkit. A message
+ *	widget displays a multi-line string in a window according to a
+ *	particular aspect ratio.
  *
  * Copyright (c) 1990-1994 The Regents of the University of California.
  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  * Copyright (c) 1998-2000 by Ajuba Solutions.
  *
- * 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: tkMessage.c,v 1.14 2002/08/05 04:30:40 dgp Exp $
+ * RCS: @(#) $Id: tkMessage.c,v 1.15 2005/11/14 22:44:11 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -20,18 +20,18 @@
 #include "tkInt.h"
 
 /*
- * A data structure of the following type is kept for each message
- * widget managed by this file:
+ * A data structure of the following type is kept for each message widget
+ * managed by this file:
  */
 
 typedef struct {
-    Tk_Window tkwin;		/* Window that embodies the message.  NULL
+    Tk_Window tkwin;		/* Window that embodies the message. NULL
 				 * means that the window has been destroyed
 				 * but the data structures haven't yet been
 				 * cleaned up.*/
     Tk_OptionTable optionTable;	/* Table that defines options available for
 				 * this widget. */
-    Display *display;		/* Display containing widget.  Used, among
+    Display *display;		/* Display containing widget. Used, among
 				 * other things, so that resources can be
 				 * freed even after tkwin has gone away. */
     Tcl_Interp *interp;		/* Interpreter associated with message. */
@@ -48,8 +48,8 @@ typedef struct {
 				 * If non-NULL, message displays the contents
 				 * of this variable. */
     Tk_3DBorder border;		/* Structure used to draw 3-D border and
-				 * background.  NULL means a border hasn't
-				 * been created yet. */
+				 * background. NULL means a border hasn't been
+				 * created yet. */
     int borderWidth;		/* Width of border. */
     int relief;			/* 3-D effect: TK_RELIEF_RAISED, etc. */
     int highlightWidth;		/* Width in pixels of highlight to draw
@@ -63,7 +63,7 @@ typedef struct {
     XColor *fgColorPtr;		/* Foreground color in normal mode. */
     Tcl_Obj *padXPtr, *padYPtr;	/* Tcl_Obj rep's of padX, padY values. */
     int padX, padY;		/* User-requested extra space around text. */
-    int width;			/* User-requested width, in pixels.  0 means
+    int width;			/* User-requested width, in pixels. 0 means
 				 * compute width using aspect ratio below. */
     int aspect;			/* Desired aspect ratio for window
 				 * (100*width/height). */
@@ -84,10 +84,10 @@ typedef struct {
      */
 
     Tk_Cursor cursor;		/* Current cursor for window, or None. */
-    char *takeFocus;		/* Value of -takefocus option;  not used in
-				 * the C code, but used by keyboard traversal
-				 * scripts.  Malloc'ed, but may be NULL. */
-    int flags;			/* Various flags;  see below for
+    char *takeFocus;		/* Value of -takefocus option; not used in the
+				 * C code, but used by keyboard traversal
+				 * scripts. Malloc'ed, but may be NULL. */
+    int flags;			/* Various flags; see below for
 				 * definitions. */
 } Message;
 
@@ -118,9 +118,9 @@ static Tk_OptionSpec optionSpecs[] = {
     {TK_OPTION_BORDER, "-background", "background", "Background",
 	 DEF_MESSAGE_BG_COLOR, -1, Tk_Offset(Message, border), 0,
 	 (ClientData) DEF_MESSAGE_BG_MONO, 0},
-    {TK_OPTION_SYNONYM, "-bd", (char *) NULL, (char *) NULL, (char *) NULL,
+    {TK_OPTION_SYNONYM, "-bd", NULL, NULL, NULL,
 	 0, -1, 0, (ClientData) "-borderwidth", 0},
-    {TK_OPTION_SYNONYM, "-bg", (char *) NULL, (char *) NULL, (char *) NULL,
+    {TK_OPTION_SYNONYM, "-bg", NULL, NULL, NULL,
 	 0, -1, 0, (ClientData) "-background", 0},
     {TK_OPTION_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
 	 DEF_MESSAGE_BORDER_WIDTH, -1,
@@ -128,7 +128,7 @@ static Tk_OptionSpec optionSpecs[] = {
     {TK_OPTION_CURSOR, "-cursor", "cursor", "Cursor",
 	 DEF_MESSAGE_CURSOR, -1, Tk_Offset(Message, cursor),
 	 TK_OPTION_NULL_OK, 0, 0},
-    {TK_OPTION_SYNONYM, "-fg", (char *) NULL, (char *) NULL, (char *) NULL,
+    {TK_OPTION_SYNONYM, "-fg", NULL, NULL, NULL,
 	 0, -1, 0, (ClientData) "-foreground", 0},
     {TK_OPTION_FONT, "-font", "font", "Font",
 	DEF_MESSAGE_FONT, -1, Tk_Offset(Message, tkfont), 0, 0, 0},
@@ -163,35 +163,31 @@ static Tk_OptionSpec optionSpecs[] = {
 	TK_OPTION_NULL_OK, 0, 0},
     {TK_OPTION_PIXELS, "-width", "width", "Width",
 	DEF_MESSAGE_WIDTH, -1, Tk_Offset(Message, width), 0, 0 ,0},
-    {TK_OPTION_END, (char *) NULL, (char *) NULL, (char *) NULL,
-	(char *) NULL, 0, 0, 0, 0}
+    {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, 0, 0, 0}
 };
 
 /*
- * Forward declarations for procedures defined later in this file:
+ * Forward declarations for functions defined later in this file:
  */
 
-static void		MessageCmdDeletedProc _ANSI_ARGS_((
-			    ClientData clientData));
-static void		MessageEventProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static char *		MessageTextVarProc _ANSI_ARGS_((ClientData clientData,
+static void		MessageCmdDeletedProc(ClientData clientData);
+static void		MessageEventProc(ClientData clientData,
+			    XEvent *eventPtr);
+static char *		MessageTextVarProc(ClientData clientData,
 			    Tcl_Interp *interp, CONST char *name1,
-			    CONST char *name2, int flags));
-static int		MessageWidgetObjCmd _ANSI_ARGS_((ClientData clientData,
+			    CONST char *name2, int flags);
+static int		MessageWidgetObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
-	                    Tcl_Obj *CONST objv[]));
-static void		MessageWorldChanged _ANSI_ARGS_((
-			    ClientData instanceData));
-static void		ComputeMessageGeometry _ANSI_ARGS_((Message *msgPtr));
-static int		ConfigureMessage _ANSI_ARGS_((Tcl_Interp *interp,
-			    Message *msgPtr, int objc, Tcl_Obj *CONST objv[],
-			    int flags));
-static void		DestroyMessage _ANSI_ARGS_((char *memPtr));
-static void		DisplayMessage _ANSI_ARGS_((ClientData clientData));
+			    Tcl_Obj *CONST objv[]);
+static void		MessageWorldChanged(ClientData instanceData);
+static void		ComputeMessageGeometry(Message *msgPtr);
+static int		ConfigureMessage(Tcl_Interp *interp, Message *msgPtr,
+			    int objc, Tcl_Obj *CONST objv[], int flags);
+static void		DestroyMessage(char *memPtr);
+static void		DisplayMessage(ClientData clientData);
 
 /*
- * The structure below defines message class behavior by means of procedures
+ * The structure below defines message class behavior by means of functions
  * that can be invoked from generic window code.
  */
 
@@ -199,16 +195,14 @@ static Tk_ClassProcs messageClass = {
     sizeof(Tk_ClassProcs),	/* size */
     MessageWorldChanged,	/* worldChangedProc */
 };
-
 
 /*
  *--------------------------------------------------------------
  *
  * Tk_MessageObjCmd --
  *
- *	This procedure is invoked to process the "message" Tcl
- *	command.  See the user documentation for details on what
- *	it does.
+ *	This function is invoked to process the "message" Tcl command. See the
+ *	user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -220,11 +214,11 @@ static Tk_ClassProcs messageClass = {
  */
 
 int
-Tk_MessageObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* NULL. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument strings. */
+Tk_MessageObjCmd(
+    ClientData clientData,	/* NULL. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument strings. */
 {
     register Message *msgPtr;
     Tk_OptionTable optionTable;
@@ -236,14 +230,14 @@ Tk_MessageObjCmd(clientData, interp, objc, objv)
     }
 
     tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp),
-	    Tcl_GetString(objv[1]), (char *) NULL);
+	    Tcl_GetString(objv[1]), NULL);
     if (tkwin == NULL) {
 	return TCL_ERROR;
     }
 
     /*
-     * Create the option table for this widget class.  If it has already
-     * been created, the cached pointer will be returned.
+     * Create the option table for this widget class. If it has already been
+     * created, the cached pointer will be returned.
      */
 
     optionTable = Tk_CreateOptionTable(interp, optionSpecs);
@@ -254,19 +248,20 @@ Tk_MessageObjCmd(clientData, interp, objc, objv)
     /*
      * Set values for those fields that don't take a 0 or NULL value.
      */
-    msgPtr->tkwin		= tkwin;
-    msgPtr->display		= Tk_Display(tkwin);
-    msgPtr->interp		= interp;
-    msgPtr->widgetCmd		= Tcl_CreateObjCommand(interp,
+
+    msgPtr->tkwin = tkwin;
+    msgPtr->display = Tk_Display(tkwin);
+    msgPtr->interp = interp;
+    msgPtr->widgetCmd = Tcl_CreateObjCommand(interp,
 	    Tk_PathName(msgPtr->tkwin), MessageWidgetObjCmd,
 	    (ClientData) msgPtr, MessageCmdDeletedProc);
-    msgPtr->optionTable		= optionTable;
-    msgPtr->relief		= TK_RELIEF_FLAT;
-    msgPtr->textGC		= None;
-    msgPtr->anchor		= TK_ANCHOR_CENTER;
-    msgPtr->aspect		= 150;
-    msgPtr->justify		= TK_JUSTIFY_LEFT;
-    msgPtr->cursor		= None;
+    msgPtr->optionTable = optionTable;
+    msgPtr->relief = TK_RELIEF_FLAT;
+    msgPtr->textGC = None;
+    msgPtr->anchor = TK_ANCHOR_CENTER;
+    msgPtr->aspect = 150;
+    msgPtr->justify = TK_JUSTIFY_LEFT;
+    msgPtr->cursor = None;
 
     Tk_SetClass(msgPtr->tkwin, "Message");
     Tk_SetClassProcs(msgPtr->tkwin, &messageClass, (ClientData) msgPtr);
@@ -292,9 +287,9 @@ Tk_MessageObjCmd(clientData, interp, objc, objv)
  *
  * MessageWidgetObjCmd --
  *
- *	This procedure is invoked to process the Tcl command
- *	that corresponds to a widget managed by this module.
- *	See the user documentation for details on what it does.
+ *	This function is invoked to process the Tcl command that corresponds
+ *	to a widget managed by this module. See the user documentation for
+ *	details on what it does.
  *
  * Results:
  *	A standard Tcl result.
@@ -306,19 +301,19 @@ Tk_MessageObjCmd(clientData, interp, objc, objv)
  */
 
 static int
-MessageWidgetObjCmd(clientData, interp, objc, objv)
-    ClientData clientData;	/* Information about message widget. */
-    Tcl_Interp *interp;		/* Current interpreter. */
-    int objc;			/* Number of arguments. */
-    Tcl_Obj *CONST objv[];	/* Argument strings. */
+MessageWidgetObjCmd(
+    ClientData clientData,	/* Information about message widget. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *CONST objv[])	/* Argument strings. */
 {
     register Message *msgPtr = (Message *) clientData;
-    static CONST char *optionStrings[] = { "cget", "configure", (char *) NULL };
+    static CONST char *optionStrings[] = { "cget", "configure", NULL };
     enum options { MESSAGE_CGET, MESSAGE_CONFIGURE };
     int index;
     int result = TCL_OK;
     Tcl_Obj *objPtr;
-    
+
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg ...?");
 	return TCL_ERROR;
@@ -330,42 +325,39 @@ MessageWidgetObjCmd(clientData, interp, objc, objv)
     }
 
     Tcl_Preserve((ClientData) msgPtr);
-    
+
     switch ((enum options) index) {
-	case MESSAGE_CGET: {
-	    if (objc != 3) {
-		Tcl_WrongNumArgs(interp, 2, objv, "option");
-		return TCL_ERROR;
-	    }
-	    objPtr = Tk_GetOptionValue(interp, (char *) msgPtr,
-		    msgPtr->optionTable, objv[2], msgPtr->tkwin);
+    case MESSAGE_CGET:
+	if (objc != 3) {
+	    Tcl_WrongNumArgs(interp, 2, objv, "option");
+	    return TCL_ERROR;
+	}
+	objPtr = Tk_GetOptionValue(interp, (char *) msgPtr,
+		msgPtr->optionTable, objv[2], msgPtr->tkwin);
+	if (objPtr == NULL) {
+	    result = TCL_ERROR;
+	} else {
+	    Tcl_SetObjResult(interp, objPtr);
+	    result = TCL_OK;
+	}
+	break;
+    case MESSAGE_CONFIGURE:
+	if (objc <= 3) {
+	    objPtr = Tk_GetOptionInfo(interp, (char *) msgPtr,
+		    msgPtr->optionTable, (objc == 3) ? objv[2] : NULL,
+		    msgPtr->tkwin);
 	    if (objPtr == NULL) {
 		result = TCL_ERROR;
 	    } else {
 		Tcl_SetObjResult(interp, objPtr);
 		result = TCL_OK;
 	    }
-	    break;
-	}
-	case MESSAGE_CONFIGURE: {
-	    if (objc <= 3) {
-		objPtr = Tk_GetOptionInfo(interp, (char *) msgPtr,
-			msgPtr->optionTable,
-			(objc == 3) ? objv[2] : (Tcl_Obj *) NULL,
-			msgPtr->tkwin);
-		if (objPtr == NULL) {
-		    result = TCL_ERROR;
-		} else {
-		    Tcl_SetObjResult(interp, objPtr);
-		    result = TCL_OK;
-		}
-	    } else {
-		result = ConfigureMessage(interp, msgPtr, objc-2, objv+2, 0);
-	    }
-	    break;
+	} else {
+	    result = ConfigureMessage(interp, msgPtr, objc-2, objv+2, 0);
 	}
+	break;
     }
-    
+
     Tcl_Release((ClientData) msgPtr);
     return result;
 }
@@ -375,9 +367,9 @@ MessageWidgetObjCmd(clientData, interp, objc, objv)
  *
  * DestroyMessage --
  *
- *	This procedure is invoked by Tcl_EventuallyFree or Tcl_Release
- *	to clean up the internal structure of a message at a safe time
- *	(when no-one is using it anymore).
+ *	This function is invoked by Tcl_EventuallyFree or Tcl_Release to clean
+ *	up the internal structure of a message at a safe time (when no-one is
+ *	using it anymore).
  *
  * Results:
  *	None.
@@ -389,8 +381,8 @@ MessageWidgetObjCmd(clientData, interp, objc, objv)
  */
 
 static void
-DestroyMessage(memPtr)
-    char *memPtr;		/* Info about message widget. */
+DestroyMessage(
+    char *memPtr)		/* Info about message widget. */
 {
     register Message *msgPtr = (Message *) memPtr;
 
@@ -400,11 +392,10 @@ DestroyMessage(memPtr)
     if (msgPtr->flags & REDRAW_PENDING) {
 	Tcl_CancelIdleCall(DisplayMessage, (ClientData) msgPtr);
     }
-   
+
     /*
-     * Free up all the stuff that requires special handling, then
-     * let Tk_FreeConfigOptions handle all the standard option-related
-     * stuff.
+     * Free up all the stuff that requires special handling, then let
+     * Tk_FreeConfigOptions handle all the standard option-related stuff.
      */
 
     if (msgPtr->textGC != None) {
@@ -428,30 +419,29 @@ DestroyMessage(memPtr)
  *
  * ConfigureMessage --
  *
- *	This procedure is called to process an argv/argc list, plus
- *	the Tk option database, in order to configure (or
- *	reconfigure) a message widget.
+ *	This function is called to process an argv/argc list, plus the Tk
+ *	option database, in order to configure (or reconfigure) a message
+ *	widget.
  *
  * Results:
- *	The return value is a standard Tcl result.  If TCL_ERROR is
- *	returned, then the interp's result contains an error message.
+ *	The return value is a standard Tcl result. If TCL_ERROR is returned,
+ *	then the interp's result contains an error message.
  *
  * Side effects:
- *	Configuration information, such as text string, colors, font,
- *	etc. get set for msgPtr;  old resources get freed, if there
- *	were any.
+ *	Configuration information, such as text string, colors, font, etc. get
+ *	set for msgPtr; old resources get freed, if there were any.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-ConfigureMessage(interp, msgPtr, objc, objv, flags)
-    Tcl_Interp *interp;		/* Used for error reporting. */
-    register Message *msgPtr;	/* Information about widget;  may or may
-				 * not already have values for some fields. */
-    int objc;			/* Number of valid entries in argv. */
-    Tcl_Obj *CONST objv[];	/* Arguments. */
-    int flags;			/* Flags to pass to Tk_ConfigureWidget. */
+ConfigureMessage(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    register Message *msgPtr,	/* Information about widget; may or may not
+				 * already have values for some fields. */
+    int objc,			/* Number of valid entries in argv. */
+    Tcl_Obj *CONST objv[],	/* Arguments. */
+    int flags)			/* Flags to pass to Tk_ConfigureWidget. */
 {
     Tk_SavedOptions savedOptions;
 
@@ -460,22 +450,21 @@ ConfigureMessage(interp, msgPtr, objc, objv, flags)
      */
 
     if (msgPtr->textVarName != NULL) {
-	Tcl_UntraceVar(interp, msgPtr->textVarName, 
+	Tcl_UntraceVar(interp, msgPtr->textVarName,
 		TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 		MessageTextVarProc, (ClientData) msgPtr);
     }
 
     if (Tk_SetOptions(interp, (char *) msgPtr, msgPtr->optionTable, objc, objv,
-	    msgPtr->tkwin, &savedOptions, (int *)NULL) != TCL_OK) {
+	    msgPtr->tkwin, &savedOptions, NULL) != TCL_OK) {
 	Tk_RestoreSavedOptions(&savedOptions);
 	return TCL_ERROR;
     }
-	    
-    
+
     /*
-     * If the message is to display the value of a variable, then set up
-     * a trace on the variable's value, create the variable if it doesn't
-     * exist, and fetch its current value.
+     * If the message is to display the value of a variable, then set up a
+     * trace on the variable's value, create the variable if it doesn't exist,
+     * and fetch its current value.
      */
 
     if (msgPtr->textVarName != NULL) {
@@ -497,9 +486,9 @@ ConfigureMessage(interp, msgPtr, objc, objv, flags)
     }
 
     /*
-     * A few other options need special processing, such as setting
-     * the background from a 3-D border or handling special defaults
-     * that couldn't be specified to Tk_ConfigureWidget.
+     * A few other options need special processing, such as setting the
+     * background from a 3-D border or handling special defaults that couldn't
+     * be specified to Tk_ConfigureWidget.
      */
 
     msgPtr->numChars = Tcl_NumUtfChars(msgPtr->string, -1);
@@ -518,22 +507,22 @@ ConfigureMessage(interp, msgPtr, objc, objv, flags)
  *
  * MessageWorldChanged --
  *
- *      This procedure is called when the world has changed in some
- *      way and the widget needs to recompute all its graphics contexts
- *	and determine its new geometry.
+ *	This function is called when the world has changed in some way and the
+ *	widget needs to recompute all its graphics contexts and determine its
+ *	new geometry.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Message will be relayed out and redisplayed.
+ *	Message will be relayed out and redisplayed.
  *
  *---------------------------------------------------------------------------
  */
- 
+
 static void
-MessageWorldChanged(instanceData)
-    ClientData instanceData;	/* Information about widget. */
+MessageWorldChanged(
+    ClientData instanceData)	/* Information about widget. */
 {
     XGCValues gcValues;
     GC gc = None;
@@ -563,8 +552,8 @@ MessageWorldChanged(instanceData)
     }
 
     /*
-     * Recompute the desired geometry for the window, and arrange for
-     * the window to be redisplayed.
+     * Recompute the desired geometry for the window, and arrange for the
+     * window to be redisplayed.
      */
 
     ComputeMessageGeometry(msgPtr);
@@ -580,23 +569,22 @@ MessageWorldChanged(instanceData)
  *
  * ComputeMessageGeometry --
  *
- *	Compute the desired geometry for a message window,
- *	taking into account the desired aspect ratio for the
- *	window.
+ *	Compute the desired geometry for a message window, taking into account
+ *	the desired aspect ratio for the window.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Tk_GeometryRequest is called to inform the geometry
- *	manager of the desired geometry for this window.
+ *	Tk_GeometryRequest is called to inform the geometry manager of the
+ *	desired geometry for this window.
  *
  *--------------------------------------------------------------
  */
 
 static void
-ComputeMessageGeometry(msgPtr)
-    register Message *msgPtr;	/* Information about window. */
+ComputeMessageGeometry(
+    register Message *msgPtr)	/* Information about window. */
 {
     int width, inc, height;
     int thisWidth, thisHeight, maxWidth;
@@ -618,12 +606,11 @@ ComputeMessageGeometry(msgPtr)
     upperBound = msgPtr->aspect + aspect;
 
     /*
-     * Do the computation in multiple passes:  start off with
-     * a very wide window, and compute its height.  Then change
-     * the width and try again.  Reduce the size of the change
-     * and iterate until dimensions are found that approximate
-     * the desired aspect ratio.  Or, if the user gave an explicit
-     * width then just use that.
+     * Do the computation in multiple passes: start off with a very wide
+     * window, and compute its height. Then change the width and try again.
+     * Reduce the size of the change and iterate until dimensions are found
+     * that approximate the desired aspect ratio. Or, if the user gave an
+     * explicit width then just use that.
      */
 
     if (msgPtr->width > 0) {
@@ -666,7 +653,7 @@ ComputeMessageGeometry(msgPtr)
  *
  * DisplayMessage --
  *
- *	This procedure redraws the contents of a message window.
+ *	This function redraws the contents of a message window.
  *
  * Results:
  *	None.
@@ -678,8 +665,8 @@ ComputeMessageGeometry(msgPtr)
  */
 
 static void
-DisplayMessage(clientData)
-    ClientData clientData;	/* Information about window. */
+DisplayMessage(
+    ClientData clientData)	/* Information about window. */
 {
     register Message *msgPtr = (Message *) clientData;
     register Tk_Window tkwin = msgPtr->tkwin;
@@ -703,8 +690,8 @@ DisplayMessage(clientData)
 	    0, TK_RELIEF_FLAT);
 
     /*
-     * Compute starting y-location for message based on message size
-     * and anchor option.
+     * Compute starting y-location for message based on message size and
+     * anchor option.
      */
 
     TkComputeAnchor(msgPtr->anchor, tkwin, msgPtr->padX, msgPtr->padY,
@@ -724,7 +711,7 @@ DisplayMessage(clientData)
 
 	bgGC = Tk_GCForColor(msgPtr->highlightBgColorPtr, Tk_WindowId(tkwin));
 	if (msgPtr->flags & GOT_FOCUS) {
-	    fgGC = Tk_GCForColor(msgPtr->highlightColorPtr, Tk_WindowId(tkwin));
+	    fgGC = Tk_GCForColor(msgPtr->highlightColorPtr,Tk_WindowId(tkwin));
 	    TkpDrawHighlightBorder(tkwin, fgGC, bgGC, msgPtr->highlightWidth,
 		    Tk_WindowId(tkwin));
 	} else {
@@ -739,23 +726,23 @@ DisplayMessage(clientData)
  *
  * MessageEventProc --
  *
- *	This procedure is invoked by the Tk dispatcher for various
- *	events on messages.
+ *	This function is invoked by the Tk dispatcher for various events on
+ *	messages.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	When the window gets deleted, internal structures get
- *	cleaned up.  When it gets exposed, it is redisplayed.
+ *	When the window gets deleted, internal structures get cleaned up.
+ *	When it gets exposed, it is redisplayed.
  *
  *--------------------------------------------------------------
  */
 
 static void
-MessageEventProc(clientData, eventPtr)
-    ClientData clientData;	/* Information about window. */
-    XEvent *eventPtr;		/* Information about event. */
+MessageEventProc(
+    ClientData clientData,	/* Information about window. */
+    XEvent *eventPtr)		/* Information about event. */
 {
     Message *msgPtr = (Message *) clientData;
 
@@ -781,7 +768,7 @@ MessageEventProc(clientData, eventPtr)
     }
     return;
 
-    redraw:
+  redraw:
     if ((msgPtr->tkwin != NULL) && !(msgPtr->flags & REDRAW_PENDING)) {
 	Tcl_DoWhenIdle(DisplayMessage, (ClientData) msgPtr);
 	msgPtr->flags |= REDRAW_PENDING;
@@ -793,9 +780,9 @@ MessageEventProc(clientData, eventPtr)
  *
  * MessageCmdDeletedProc --
  *
- *	This procedure is invoked when a widget command is deleted.  If
- *	the widget isn't already in the process of being destroyed,
- *	this command destroys it.
+ *	This function is invoked when a widget command is deleted. If the
+ *	widget isn't already in the process of being destroyed, this command
+ *	destroys it.
  *
  * Results:
  *	None.
@@ -807,16 +794,16 @@ MessageEventProc(clientData, eventPtr)
  */
 
 static void
-MessageCmdDeletedProc(clientData)
-    ClientData clientData;	/* Pointer to widget record for widget. */
+MessageCmdDeletedProc(
+    ClientData clientData)	/* Pointer to widget record for widget. */
 {
     Message *msgPtr = (Message *) clientData;
 
     /*
-     * This procedure could be invoked either because the window was
-     * destroyed and the command was then deleted (in which case tkwin
-     * is NULL) or because the command was deleted, and then this procedure
-     * destroys the widget.
+     * This function could be invoked either because the window was destroyed
+     * and the command was then deleted (in which case tkwin is NULL) or
+     * because the command was deleted, and then this function destroys the
+     * widget.
      */
 
     if (!(msgPtr->flags & MESSAGE_DELETED)) {
@@ -829,34 +816,33 @@ MessageCmdDeletedProc(clientData)
  *
  * MessageTextVarProc --
  *
- *	This procedure is invoked when someone changes the variable
- *	whose contents are to be displayed in a message.
+ *	This function is invoked when someone changes the variable whose
+ *	contents are to be displayed in a message.
  *
  * Results:
  *	NULL is always returned.
  *
  * Side effects:
- *	The text displayed in the message will change to match the
- *	variable.
+ *	The text displayed in the message will change to match the variable.
  *
  *--------------------------------------------------------------
  */
 
 	/* ARGSUSED */
 static char *
-MessageTextVarProc(clientData, interp, name1, name2, flags)
-    ClientData clientData;	/* Information about message. */
-    Tcl_Interp *interp;		/* Interpreter containing variable. */
-    CONST char *name1;		/* Name of variable. */
-    CONST char *name2;		/* Second part of variable name. */
-    int flags;			/* Information about what happened. */
+MessageTextVarProc(
+    ClientData clientData,	/* Information about message. */
+    Tcl_Interp *interp,		/* Interpreter containing variable. */
+    CONST char *name1,		/* Name of variable. */
+    CONST char *name2,		/* Second part of variable name. */
+    int flags)			/* Information about what happened. */
 {
     register Message *msgPtr = (Message *) clientData;
     CONST char *value;
 
     /*
-     * If the variable is unset, then immediately recreate it unless
-     * the whole interpreter is going away.
+     * If the variable is unset, then immediately recreate it unless the whole
+     * interpreter is going away.
      */
 
     if (flags & TCL_TRACE_UNSETS) {
@@ -867,7 +853,7 @@ MessageTextVarProc(clientData, interp, name1, name2, flags)
 		    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 		    MessageTextVarProc, clientData);
 	}
-	return (char *) NULL;
+	return NULL;
     }
 
     value = Tcl_GetVar(interp, msgPtr->textVarName, TCL_GLOBAL_ONLY);
@@ -887,5 +873,13 @@ MessageTextVarProc(clientData, interp, name1, name2, flags)
 	Tcl_DoWhenIdle(DisplayMessage, (ClientData) msgPtr);
 	msgPtr->flags |= REDRAW_PENDING;
     }
-    return (char *) NULL;
+    return NULL;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */