ANSIfy

8 files changed, 1598 insertions, 1531 deletions

diff --git a/unix/tkUnix.c b/unix/tkUnix.c
index 677569e..2e174b7 100644
--- a/unix/tkUnix.c
+++ b/unix/tkUnix.c
@@ -1,16 +1,16 @@
-/* 
+/*
  * tkUnix.c --
  *
- *	This file contains procedures that are UNIX/X-specific, and
- *	will probably have to be written differently for Windows or
- *	Macintosh platforms.
+ *	This file contains procedures that are UNIX/X-specific, and will
+ *	probably have to be written differently for Windows or Macintosh
+ *	platforms.
  *
  * Copyright (c) 1995 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: tkUnix.c,v 1.11 2005/08/10 22:02:22 dkf Exp $
+ * RCS: @(#) $Id: tkUnix.c,v 1.12 2005/11/14 11:54:21 dkf Exp $
  */
 
 #include <tkInt.h>
@@ -23,9 +23,9 @@
  *
  * TkGetServerInfo --
  *
- *	Given a window, this procedure returns information about
- *	the window server for that window.  This procedure provides
- *	the guts of the "winfo server" command.
+ *	Given a window, this procedure returns information about the window
+ *	server for that window. This procedure provides the guts of the "winfo
+ *	server" command.
  *
  * Results:
  *	None.
@@ -37,11 +37,11 @@
  */
 
 void
-TkGetServerInfo(interp, tkwin)
-    Tcl_Interp *interp;		/* The server information is returned in
-				 * this interpreter's result. */
-    Tk_Window tkwin;		/* Token for window;  this selects a
-				 * particular display and server. */
+TkGetServerInfo(
+    Tcl_Interp *interp,		/* The server information is returned in this
+				 * interpreter's result. */
+    Tk_Window tkwin)		/* Token for window; this selects a particular
+				 * display and server. */
 {
     char buffer[8 + TCL_INTEGER_SPACE * 2];
     char buffer2[TCL_INTEGER_SPACE];
@@ -62,8 +62,8 @@ TkGetServerInfo(interp, tkwin)
  *	initialization.
  *
  * Results:
- *	Returns the argument or a string that should not be freed by
- *	the caller.
+ *	Returns the argument or a string that should not be freed by the
+ *	caller.
  *
  * Side effects:
  *	None.
@@ -72,9 +72,10 @@ TkGetServerInfo(interp, tkwin)
  */
 
 CONST char *
-TkGetDefaultScreenName(interp, screenName)
-    Tcl_Interp *interp;		/* Interp used to find environment variables. */
-    CONST char *screenName;	/* Screen name from command line, or NULL. */
+TkGetDefaultScreenName(
+    Tcl_Interp *interp,		/* Interp used to find environment
+				 * variables. */
+    CONST char *screenName)	/* Screen name from command line, or NULL. */
 {
     if ((screenName == NULL) || (screenName[0] == '\0')) {
 	screenName = Tcl_GetVar2(interp, "env", "DISPLAY", TCL_GLOBAL_ONLY);
@@ -99,11 +100,11 @@ TkGetDefaultScreenName(interp, screenName)
  */
 
 void
-Tk_UpdatePointer(tkwin, x, y, state)
-    Tk_Window tkwin;		/* Window to which pointer event
-				 * is reported. May be NULL. */
-    int x, y;			/* Pointer location in root coords. */
-    int state;			/* Modifier state mask. */
+Tk_UpdatePointer(
+    Tk_Window tkwin,		/* Window to which pointer event is reported.
+				 * May be NULL. */
+    int x, int y,		/* Pointer location in root coords. */
+    int state)			/* Modifier state mask. */
 {
   /*
    * This function intentionally left blank
@@ -128,15 +129,15 @@ Tk_UpdatePointer(tkwin, x, y, state)
  */
 
 void
-TkpBuildRegionFromAlphaData(region, x, y, width, height, dataPtr,
-	pixelStride, lineStride)
-     TkRegion region;		/* Region to be updated. */
-    unsigned int x, y;		/* Where in region to update. */
-    unsigned int width, height;	/* Size of rectangle to update. */
-    unsigned char *dataPtr;	/* Data to read from. */
-    unsigned int pixelStride;	/* Num bytes from one piece of alpha data to
+TkpBuildRegionFromAlphaData(
+    TkRegion region,		/* Region to be updated. */
+    unsigned x, unsigned y,	/* Where in region to update. */
+    unsigned width, unsigned height,
+				/* Size of rectangle to update. */
+    unsigned char *dataPtr,	/* Data to read from. */
+    unsigned pixelStride,	/* Num bytes from one piece of alpha data to
 				 * the next in the line. */
-    unsigned int lineStride;	/* Num bytes from one line of alpha data to
+    unsigned lineStride)	/* Num bytes from one line of alpha data to
 				 * the next line. */
 {
     unsigned char *lineDataPtr;
@@ -178,16 +179,16 @@ TkpBuildRegionFromAlphaData(region, x, y, width, height, dataPtr,
 
 /*
  *----------------------------------------------------------------------
- * 
+ *
  * Tk_GetUserInactiveTime --
  *
  *	Return the number of milliseconds the user was inactive.
  *
  * Results:
- *	The number of milliseconds since the user's latest interaction
- *	with the system on the given display, or -1 if the
- *	XScreenSaver extension is not supported by the client
- *	libraries or the X server implementation.
+ *	The number of milliseconds since the user's latest interaction with
+ *	the system on the given display, or -1 if the XScreenSaver extension
+ *	is not supported by the client libraries or the X server
+ *	implementation.
  *
  * Side effects:
  *	None.
@@ -195,23 +196,29 @@ TkpBuildRegionFromAlphaData(region, x, y, width, height, dataPtr,
  */
 
 long
-Tk_GetUserInactiveTime(dpy)
-    Display *dpy;			/* The display for which to query the
-					 * inactive time. */
+Tk_GetUserInactiveTime(
+    Display *dpy)		/* The display for which to query the inactive
+				 * time. */
 {
     long inactiveTime = -1;
 #ifdef HAVE_XSS
     int eventBase, errorBase, major, minor;
 
-    /* Calling XScreenSaverQueryVersion seems to be needed to prevent
-     * a crash on some buggy versions of XFree86 */
+    /*
+     * Calling XScreenSaverQueryVersion seems to be needed to prevent a crash
+     * on some buggy versions of XFree86.
+     */
+
     if (XScreenSaverQueryExtension(dpy, &eventBase, &errorBase) &&
 	XScreenSaverQueryVersion(dpy, &major, &minor)) {
 
 	XScreenSaverInfo *info = XScreenSaverAllocInfo();
 
 	if (info == NULL) {
-	    /* we are out of memory */
+	    /*
+	     * We are out of memory.
+	     */
+
 	    Tcl_Panic("Out of memory: XScreenSaverAllocInfo failed in Tk_GetUserInactiveTime");
 	}
 	if (XScreenSaverQueryInfo(dpy, DefaultRootWindow(dpy), info)) {
@@ -234,15 +241,23 @@ Tk_GetUserInactiveTime(dpy)
  *	none
  *
  * Side effects:
- *	The user inactivity timer of the underlaying windowing system
- *	is reset to zero.
+ *	The user inactivity timer of the underlaying windowing system is reset
+ *	to zero.
  *
  *----------------------------------------------------------------------
  */
 
 void
-Tk_ResetUserInactiveTime(dpy)
-    Display *dpy;
+Tk_ResetUserInactiveTime(
+    Display *dpy)
 {
     XResetScreenSaver(dpy);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixButton.c b/unix/tkUnixButton.c
index cc29a1c..d35524b 100644
--- a/unix/tkUnixButton.c
+++ b/unix/tkUnixButton.c
@@ -1,15 +1,14 @@
-/* 
+/*
  * tkUnixButton.c --
  *
- *	This file implements the Unix specific portion of the button
- *	widgets.
+ *	This file implements the Unix specific portion of the button widgets.
  *
  * 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: tkUnixButton.c,v 1.20 2004/12/02 02:10:38 hobbs Exp $
+ * RCS: @(#) $Id: tkUnixButton.c,v 1.21 2005/11/14 11:54:21 dkf Exp $
  */
 
 #include "tkButton.h"
@@ -24,7 +23,7 @@ typedef struct UnixButton {
 } UnixButton;
 
 /*
- * The class procedure table for the button widgets.
+ * The class function table for the button widgets.
  */
 
 Tk_ClassProcs tkpButtonProcs = {
@@ -33,9 +32,9 @@ Tk_ClassProcs tkpButtonProcs = {
 };
 
 /*
- * The button image
- * the header info here is ignored, it's the image that's
- * important.  The colors will be applied as follows:
+ * The button image.
+ * The header info here is ignored, it's the image that's important. The
+ * colors will be applied as follows:
  *   A = Background
  *   B = Background
  *   C = 3D light
@@ -91,6 +90,7 @@ static char *button_images[] = {
 /*
  * Sizes and offsets into above XPM file.
  */
+
 #define CHECK_BUTTON_DIM    13
 #define CHECK_MENU_DIM       9
 #define CHECK_START          9
@@ -110,20 +110,19 @@ static char *button_images[] = {
 /*
  * Indicator Draw Modes
  */
+
 #define CHECK_BUTTON 0
 #define CHECK_MENU   1
 #define RADIO_BUTTON 2
 #define RADIO_MENU   3
-
 
 /*
  *----------------------------------------------------------------------
  *
  * TkpDrawCheckIndicator -
  *
- *	Draws the checkbox image in the drawable at the (x,y)
- *	location, value, and state given.  This routine is use by the
- *	button and menu widgets
+ *	Draws the checkbox image in the drawable at the (x,y) location, value,
+ *	and state given. This routine is use by the button and menu widgets
  *
  * Results:
  *	None.
@@ -134,20 +133,19 @@ static char *button_images[] = {
  *----------------------------------------------------------------------
  */
 
-void 
-TkpDrawCheckIndicator(tkwin, display, d, x, y, bgBorder, indicatorColor,
-	selectColor, disableColor, on, disabled, mode)
-    Tk_Window tkwin;				/* handle for resource alloc */
-    Display *display;
-    Drawable d;					/* what to draw on */
-    int x, y;					/* where to draw */
-    Tk_3DBorder bgBorder;			/* colors of the border */
-    XColor *indicatorColor;			/* color of the indicator */
-    XColor *selectColor;			/* color when selected */
-    XColor *disableColor;			/* color when disabled */
-    int on;					/* are we on? */
-    int disabled;				/* are we disabled? */
-    int mode;					/* kind of indicator to draw */
+void
+TkpDrawCheckIndicator(
+    Tk_Window tkwin,		/* handle for resource alloc */
+    Display *display,
+    Drawable d,			/* what to draw on */
+    int x, int y,		/* where to draw */
+    Tk_3DBorder bgBorder,	/* colors of the border */
+    XColor *indicatorColor,	/* color of the indicator */
+    XColor *selectColor,	/* color when selected */
+    XColor *disableColor,	/* color when disabled */
+    int on,			/* are we on? */
+    int disabled,		/* are we disabled? */
+    int mode)			/* kind of indicator to draw */
 {
     int ix, iy;
     int dim;
@@ -180,23 +178,23 @@ TkpDrawCheckIndicator(tkwin, display, d, x, y, bgBorder, indicatorColor,
     depth = Tk_Depth(tkwin);
 
     /*
-     * Compute starting point and dimensions of image inside
-     * button_images to be used.
+     * Compute starting point and dimensions of image inside button_images to
+     * be used.
      */
 
     switch (mode) {
     default:
     case CHECK_BUTTON:
-	imgsel = on == 2 ? CHECK_DISON_OFFSET : 
-	    on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
+	imgsel = on == 2 ? CHECK_DISON_OFFSET :
+		on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
 	imgsel += disabled  && on != 2 ? CHECK_DISOFF_OFFSET : 0;
 	imgstart = CHECK_START;
 	dim = CHECK_BUTTON_DIM;
 	break;
 
     case CHECK_MENU:
-	imgsel = on == 2 ? CHECK_DISOFF_OFFSET : 
-	    on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
+	imgsel = on == 2 ? CHECK_DISOFF_OFFSET :
+		on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
 	imgsel += disabled  && on != 2 ? CHECK_DISOFF_OFFSET : 0;
 	imgstart = CHECK_START + 2;
 	imgsel += 2;
@@ -205,15 +203,15 @@ TkpDrawCheckIndicator(tkwin, display, d, x, y, bgBorder, indicatorColor,
 
     case RADIO_BUTTON:
 	imgsel = on == 2 ? RADIO_DISON_OFFSET :
-	    on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
+		on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
 	imgsel += disabled && on != 2 ? RADIO_DISOFF_OFFSET : 0;
 	imgstart = RADIO_START;
 	dim = RADIO_BUTTON_DIM;
 	break;
 
-    case RADIO_MENU:    
+    case RADIO_MENU:
 	imgsel = on == 2 ? RADIO_DISOFF_OFFSET :
-	    on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
+		on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
 	imgsel += disabled && on != 2 ? RADIO_DISOFF_OFFSET : 0;
 	imgstart = RADIO_START + 3;
 	imgsel += 3;
@@ -222,9 +220,8 @@ TkpDrawCheckIndicator(tkwin, display, d, x, y, bgBorder, indicatorColor,
     }
 
     /*
-     * Allocate the drawing areas to use.  Note that we use
-     * double-buffering here because not all code paths leading to
-     * this function do so.
+     * Allocate the drawing areas to use. Note that we use double-buffering
+     * here because not all code paths leading to this function do so.
      */
 
     pixmap = Tk_GetPixmap(display, d, dim, dim, depth);
@@ -252,13 +249,13 @@ TkpDrawCheckIndicator(tkwin, display, d, x, y, bgBorder, indicatorColor,
     imgColors[1 /*B*/] =
 	    Tk_GetColorByValue(tkwin, bg_brdr->bgColorPtr)->pixel;
     imgColors[2 /*C*/] = (bg_brdr->lightColorPtr != NULL) ?
-	Tk_GetColorByValue(tkwin, bg_brdr->lightColorPtr)->pixel :
-	WhitePixelOfScreen(bg_brdr->screen);
+	    Tk_GetColorByValue(tkwin, bg_brdr->lightColorPtr)->pixel :
+	    WhitePixelOfScreen(bg_brdr->screen);
     imgColors[3 /*D*/] =
 	    Tk_GetColorByValue(tkwin, selectColor)->pixel;
-    imgColors[4 /*E*/] = (bg_brdr->darkColorPtr != NULL) ? 
-	Tk_GetColorByValue(tkwin, bg_brdr->darkColorPtr)->pixel :
-	BlackPixelOfScreen(bg_brdr->screen);
+    imgColors[4 /*E*/] = (bg_brdr->darkColorPtr != NULL) ?
+	    Tk_GetColorByValue(tkwin, bg_brdr->darkColorPtr)->pixel :
+	    BlackPixelOfScreen(bg_brdr->screen);
     imgColors[5 /*F*/] =
 	    Tk_GetColorByValue(tkwin, bg_brdr->bgColorPtr)->pixel;
     imgColors[6 /*G*/] =
@@ -317,10 +314,10 @@ TkpDrawCheckIndicator(tkwin, display, d, x, y, bgBorder, indicatorColor,
  */
 
 TkButton *
-TkpCreateButton(tkwin)
-    Tk_Window tkwin;
+TkpCreateButton(
+    Tk_Window tkwin)
 {
-    UnixButton *butPtr = (UnixButton *)ckalloc(sizeof(UnixButton));
+    UnixButton *butPtr = (UnixButton *) ckalloc(sizeof(UnixButton));
     return (TkButton *) butPtr;
 }
 
@@ -329,29 +326,29 @@ TkpCreateButton(tkwin)
  *
  * TkpDisplayButton --
  *
- *	This procedure is invoked to display a button widget.  It is
- *	normally invoked as an idle handler.
+ *	This function is invoked to display a button widget. It is normally
+ *	invoked as an idle handler.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Commands are output to X to display the button in its
- *	current mode.  The REDRAW_PENDING flag is cleared.
+ *	Commands are output to X to display the button in its current mode.
+ *	The REDRAW_PENDING flag is cleared.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkpDisplayButton(clientData)
-    ClientData clientData;	/* Information about widget. */
+TkpDisplayButton(
+    ClientData clientData)	/* Information about widget. */
 {
     register TkButton *butPtr = (TkButton *) clientData;
     GC gc;
     Tk_3DBorder border;
     Pixmap pixmap;
-    int x = 0;			/* Initialization only needed to stop
-				 * compiler warning. */
+    int x = 0;			/* Initialization only needed to stop compiler
+				 * warning. */
     int y, relief;
     Tk_Window tkwin = butPtr->tkwin;
     int width, height, fullWidth, fullHeight;
@@ -359,12 +356,12 @@ TkpDisplayButton(clientData)
     int haveImage = 0, haveText = 0;
     int offset;			/* 1 means this is a button widget, so we
 				 * offset the text to make the button appear
-				 * to move up and down as the relief changes.
-				 */
+				 * to move up and down as the relief
+				 * changes. */
     int imageWidth, imageHeight;
-    int imageXOffset = 0, imageYOffset = 0; /* image information that will
-					     * be used to restrict disabled
-					     * pixmap as well */
+    int imageXOffset = 0, imageYOffset = 0;
+				/* image information that will be used to
+				 * restrict disabled pixmap as well */
 
     butPtr->flags &= ~REDRAW_PENDING;
     if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
@@ -387,9 +384,8 @@ TkpDisplayButton(clientData)
     }
 
     /*
-     * Override the relief specified for the button if this is a
-     * checkbutton or radiobutton and there's no indicator.  The new
-     * relief is as follows:
+     * Override the relief specified for the button if this is a checkbutton
+     * or radiobutton and there's no indicator. The new relief is as follows:
      *      If the button is select  --> "sunken"
      *      If relief==overrelief    --> relief
      *      Otherwise                --> overrelief
@@ -403,15 +399,15 @@ TkpDisplayButton(clientData)
      *       on         no               sunken
      *       on         yes              sunken
      *
-     * This is accomplished by configuring the checkbutton or radiobutton
-     * like this:
+     * This is accomplished by configuring the checkbutton or radiobutton like
+     * this:
      *
      *     -indicatoron 0 -overrelief raised -offrelief flat
      *
      * Bindings (see library/button.tcl) will copy the -overrelief into
-     * -relief on mouseover.  Hence, we can tell if we are in mouse-over by
-     * comparing relief against overRelief.  This is an aweful kludge, but
-     * it gives use the desired behavior while keeping the code backwards
+     * -relief on mouseover. Hence, we can tell if we are in mouse-over by
+     * comparing relief against overRelief. This is an aweful kludge, but it
+     * gives use the desired behavior while keeping the code backwards
      * compatible.
      */
 
@@ -427,10 +423,10 @@ TkpDisplayButton(clientData)
     offset = (butPtr->type == TYPE_BUTTON) && !Tk_StrictMotif(butPtr->tkwin);
 
     /*
-     * In order to avoid screen flashes, this procedure redraws
-     * the button in a pixmap, then copies the pixmap to the
-     * screen in a single operation.  This means that there's no
-     * point in time where the on-screen image has been cleared.
+     * In order to avoid screen flashes, this function redraws the button in a
+     * pixmap, then copies the pixmap to the screen in a single operation.
+     * This means that there's no point in time where the on-screen image has
+     * been cleared.
      */
 
     pixmap = Tk_GetPixmap(butPtr->display, Tk_WindowId(tkwin),
@@ -453,7 +449,7 @@ TkpDisplayButton(clientData)
     imageHeight = height;
 
     haveText = (butPtr->textWidth != 0 && butPtr->textHeight != 0);
-    
+
     if (butPtr->compound != COMPOUND_NONE && haveImage && haveText) {
 	textXOffset = 0;
 	textYOffset = 0;
@@ -461,49 +457,56 @@ TkpDisplayButton(clientData)
 	fullHeight = 0;
 
 	switch ((enum compound) butPtr->compound) {
-	    case COMPOUND_TOP: 
-	    case COMPOUND_BOTTOM: {
-		/* Image is above or below text */
-		if (butPtr->compound == COMPOUND_TOP) {
-		    textYOffset = height + butPtr->padY;
-		} else {
-		    imageYOffset = butPtr->textHeight + butPtr->padY;
-		}
-		fullHeight = height + butPtr->textHeight + butPtr->padY;
-		fullWidth = (width > butPtr->textWidth ? width :
-			butPtr->textWidth);
-		textXOffset = (fullWidth - butPtr->textWidth)/2;
-		imageXOffset = (fullWidth - width)/2;
-		break;
-	    }
-	    case COMPOUND_LEFT:
-	    case COMPOUND_RIGHT: {
-		/* Image is left or right of text */
-		if (butPtr->compound == COMPOUND_LEFT) {
-		    textXOffset = width + butPtr->padX;
-		} else {
-		    imageXOffset = butPtr->textWidth + butPtr->padX;
-		}
-		fullWidth = butPtr->textWidth + butPtr->padX + width;
-		fullHeight = (height > butPtr->textHeight ? height :
-			butPtr->textHeight);
-		textYOffset = (fullHeight - butPtr->textHeight)/2;
-		imageYOffset = (fullHeight - height)/2;
-		break;
+	case COMPOUND_TOP:
+	case COMPOUND_BOTTOM:
+	    /*
+	     * Image is above or below text.
+	     */
+
+	    if (butPtr->compound == COMPOUND_TOP) {
+		textYOffset = height + butPtr->padY;
+	    } else {
+		imageYOffset = butPtr->textHeight + butPtr->padY;
 	    }
-	    case COMPOUND_CENTER: {
-		/* Image and text are superimposed */
-		fullWidth = (width > butPtr->textWidth ? width :
-			butPtr->textWidth);
-		fullHeight = (height > butPtr->textHeight ? height :
-			butPtr->textHeight);
-		textXOffset = (fullWidth - butPtr->textWidth)/2;
-		imageXOffset = (fullWidth - width)/2;
-		textYOffset = (fullHeight - butPtr->textHeight)/2;
-		imageYOffset = (fullHeight - height)/2;
-		break;
+	    fullHeight = height + butPtr->textHeight + butPtr->padY;
+	    fullWidth = (width > butPtr->textWidth ? width :
+		    butPtr->textWidth);
+	    textXOffset = (fullWidth - butPtr->textWidth)/2;
+	    imageXOffset = (fullWidth - width)/2;
+	    break;
+	case COMPOUND_LEFT:
+	case COMPOUND_RIGHT:
+	    /*
+	     * Image is left or right of text.
+	     */
+
+	    if (butPtr->compound == COMPOUND_LEFT) {
+		textXOffset = width + butPtr->padX;
+	    } else {
+		imageXOffset = butPtr->textWidth + butPtr->padX;
 	    }
-	    case COMPOUND_NONE: {break;}
+	    fullWidth = butPtr->textWidth + butPtr->padX + width;
+	    fullHeight = (height > butPtr->textHeight ? height :
+		    butPtr->textHeight);
+	    textYOffset = (fullHeight - butPtr->textHeight)/2;
+	    imageYOffset = (fullHeight - height)/2;
+	    break;
+	case COMPOUND_CENTER:
+	    /*
+	     * Image and text are superimposed.
+	     */
+
+	    fullWidth = (width > butPtr->textWidth ? width :
+		    butPtr->textWidth);
+	    fullHeight = (height > butPtr->textHeight ? height :
+		    butPtr->textHeight);
+	    textXOffset = (fullWidth - butPtr->textWidth)/2;
+	    imageXOffset = (fullWidth - width)/2;
+	    textYOffset = (fullHeight - butPtr->textHeight)/2;
+	    imageYOffset = (fullHeight - height)/2;
+	    break;
+	case COMPOUND_NONE:
+	    break;
 	}
 
 	TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY,
@@ -526,8 +529,8 @@ TkpDisplayButton(clientData)
 
 	if (butPtr->image != NULL) {
 	    /*
-	     * Do boundary clipping, so that Tk_RedrawImage is passed
-	     * valid coordinates. [Bug 979239]
+	     * Do boundary clipping, so that Tk_RedrawImage is passed valid
+	     * coordinates. [Bug 979239]
 	     */
 
 	    if (imageXOffset < 0) {
@@ -578,7 +581,7 @@ TkpDisplayButton(clientData)
 	    TkComputeAnchor(butPtr->anchor, tkwin, 0, 0,
 		    butPtr->indicatorSpace + width, height, &x, &y);
 	    x += butPtr->indicatorSpace;
-	    
+
 	    x += offset;
 	    y += offset;
 	    if (relief == TK_RELIEF_RAISED) {
@@ -638,9 +641,9 @@ TkpDisplayButton(clientData)
  	    TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY,
 		    butPtr->indicatorSpace + butPtr->textWidth,
 		    butPtr->textHeight, &x, &y);
-	    
+
 	    x += butPtr->indicatorSpace;
-	    
+
 	    x += offset;
 	    y += offset;
 	    if (relief == TK_RELIEF_RAISED) {
@@ -657,11 +660,10 @@ TkpDisplayButton(clientData)
 	    y += butPtr->textHeight/2;
 	}
     }
-    
+
     /*
-     * Draw the indicator for check buttons and radio buttons.  At this
-     * point x and y refer to the top-left corner of the text or image
-     * or bitmap.
+     * Draw the indicator for check buttons and radio buttons. At this point,
+     * x and y refer to the top-left corner of the text or image or bitmap.
      */
 
     if ((butPtr->type == TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
@@ -676,7 +678,8 @@ TkpDisplayButton(clientData)
 	    y = Tk_Height(tkwin)/2;
 	    TkpDrawCheckIndicator(tkwin, butPtr->display, pixmap, x, y,
 		    border, butPtr->normalFg, selColor, butPtr->disabledFg,
-		    ((butPtr->flags & SELECTED)?1:(butPtr->flags & TRISTATED)?2:0), 
+		    ((butPtr->flags & SELECTED) ? 1 :
+			    (butPtr->flags & TRISTATED) ? 2 : 0),
 		    (butPtr->state == STATE_DISABLED), CHECK_BUTTON);
 	}
     } else if ((butPtr->type == TYPE_RADIO_BUTTON) && butPtr->indicatorOn) {
@@ -691,16 +694,17 @@ TkpDisplayButton(clientData)
 	    y = Tk_Height(tkwin)/2;
 	    TkpDrawCheckIndicator(tkwin, butPtr->display, pixmap,  x, y,
 		    border, butPtr->normalFg, selColor, butPtr->disabledFg,
-		    ((butPtr->flags & SELECTED)?1:(butPtr->flags & TRISTATED)?2:0),
+		    ((butPtr->flags & SELECTED) ? 1 :
+			    (butPtr->flags & TRISTATED) ? 2 : 0),
 		    (butPtr->state == STATE_DISABLED), RADIO_BUTTON);
 	}
     }
 
     /*
      * If the button is disabled with a stipple rather than a special
-     * foreground color, generate the stippled effect.  If the widget
-     * is selected and we use a different background color when selected,
-     * must temporarily modify the GC so the stippling is the right color.
+     * foreground color, generate the stippled effect. If the widget is
+     * selected and we use a different background color when selected, must
+     * temporarily modify the GC so the stippling is the right color.
      */
 
     if ((butPtr->state == STATE_DISABLED)
@@ -710,10 +714,12 @@ TkpDisplayButton(clientData)
 	    XSetForeground(butPtr->display, butPtr->stippleGC,
 		    Tk_3DBorderColor(butPtr->selectBorder)->pixel);
 	}
+
 	/*
-	 * Stipple the whole button if no disabledFg was specified,
-	 * otherwise restrict stippling only to displayed image
+	 * Stipple the whole button if no disabledFg was specified, otherwise
+	 * restrict stippling only to displayed image
 	 */
+
 	if (butPtr->disabledFg == NULL) {
 	    XFillRectangle(butPtr->display, pixmap, butPtr->stippleGC, 0, 0,
 		    (unsigned) Tk_Width(tkwin), (unsigned) Tk_Height(tkwin));
@@ -730,11 +736,11 @@ TkpDisplayButton(clientData)
     }
 
     /*
-     * Draw the border and traversal highlight last.  This way, if the
-     * button's contents overflow they'll be covered up by the border.
-     * This code is complicated by the possible combinations of focus
-     * highlight and default rings.  We draw the focus and highlight rings
-     * using the highlight border and highlight foreground color.
+     * Draw the border and traversal highlight last. This way, if the button's
+     * contents overflow they'll be covered up by the border. This code is
+     * complicated by the possible combinations of focus highlight and default
+     * rings. We draw the focus and highlight rings using the highlight border
+     * and highlight foreground color.
      */
 
     if (relief != TK_RELIEF_FLAT) {
@@ -743,10 +749,10 @@ TkpDisplayButton(clientData)
 	if (butPtr->defaultState == DEFAULT_ACTIVE) {
 	    /*
 	     * Draw the default ring with 2 pixels of space between the
-	     * default ring and the button and the default ring and the
-	     * focus ring.  Note that we need to explicitly draw the space
-	     * in the highlightBorder color to ensure that we overwrite any
-	     * overflow text and/or a different button background color.
+	     * default ring and the button and the default ring and the focus
+	     * ring. Note that we need to explicitly draw the space in the
+	     * highlightBorder color to ensure that we overwrite any overflow
+	     * text and/or a different button background color.
 	     */
 
 	    Tk_Draw3DRectangle(tkwin, pixmap, butPtr->highlightBorder, inset,
@@ -805,8 +811,8 @@ TkpDisplayButton(clientData)
     }
 
     /*
-     * Copy the information from the off-screen pixmap onto the screen,
-     * then delete the pixmap.
+     * Copy the information from the off-screen pixmap onto the screen, then
+     * delete the pixmap.
      */
 
     XCopyArea(butPtr->display, pixmap, Tk_WindowId(tkwin),
@@ -820,9 +826,9 @@ TkpDisplayButton(clientData)
  *
  * TkpComputeButtonGeometry --
  *
- *	After changes in a button's text or bitmap, this procedure
- *	recomputes the button's geometry and passes this information
- *	along to the geometry manager for the window.
+ *	After changes in a button's text or bitmap, this function recomputes
+ *	the button's geometry and passes this information along to the
+ *	geometry manager for the window.
  *
  * Results:
  *	None.
@@ -834,8 +840,8 @@ TkpDisplayButton(clientData)
  */
 
 void
-TkpComputeButtonGeometry(butPtr)
-    register TkButton *butPtr;	/* Button whose geometry may have changed. */
+TkpComputeButtonGeometry(
+    register TkButton *butPtr)	/* Button whose geometry may have changed. */
 {
     int width, height, avgWidth, txtWidth, txtHeight;
     int haveImage = 0, haveText = 0;
@@ -857,7 +863,7 @@ TkpComputeButtonGeometry(butPtr)
     txtWidth = 0;
     txtHeight = 0;
     avgWidth = 0;
-    
+
     if (butPtr->image != NULL) {
 	Tk_SizeOfImage(butPtr->image, &width, &height);
 	haveImage = 1;
@@ -865,51 +871,58 @@ TkpComputeButtonGeometry(butPtr)
 	Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
 	haveImage = 1;
     }
-    
+
     if (haveImage == 0 || butPtr->compound != COMPOUND_NONE) {
 	Tk_FreeTextLayout(butPtr->textLayout);
-	    
+
 	butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont,
 		Tcl_GetString(butPtr->textPtr), -1, butPtr->wrapLength,
 		butPtr->justify, 0, &butPtr->textWidth, &butPtr->textHeight);
-	
+
 	txtWidth = butPtr->textWidth;
 	txtHeight = butPtr->textHeight;
 	avgWidth = Tk_TextWidth(butPtr->tkfont, "0", 1);
 	Tk_GetFontMetrics(butPtr->tkfont, &fm);
 	haveText = (txtWidth != 0 && txtHeight != 0);
     }
-    
+
     /*
-     * If the button is compound (ie, it shows both an image and text),
-     * the new geometry is a combination of the image and text geometry.
-     * We only honor the compound bit if the button has both text and an
-     * image, because otherwise it is not really a compound button.
+     * If the button is compound (i.e., it shows both an image and text), the
+     * new geometry is a combination of the image and text geometry. We only
+     * honor the compound bit if the button has both text and an image,
+     * because otherwise it is not really a compound button.
      */
 
     if (butPtr->compound != COMPOUND_NONE && haveImage && haveText) {
 	switch ((enum compound) butPtr->compound) {
-	    case COMPOUND_TOP:
-	    case COMPOUND_BOTTOM: {
-		/* Image is above or below text */
-		height += txtHeight + butPtr->padY;
-		width = (width > txtWidth ? width : txtWidth);
-		break;
-	    }
-	    case COMPOUND_LEFT:
-	    case COMPOUND_RIGHT: {
-		/* Image is left or right of text */
-		width += txtWidth + butPtr->padX;
-		height = (height > txtHeight ? height : txtHeight);
-		break;
-	    }
-	    case COMPOUND_CENTER: {
-		/* Image and text are superimposed */
-		width = (width > txtWidth ? width : txtWidth);
-		height = (height > txtHeight ? height : txtHeight);
-		break;
-	    }
-	    case COMPOUND_NONE: {break;}
+	case COMPOUND_TOP:
+	case COMPOUND_BOTTOM:
+	    /*
+	     * Image is above or below text.
+	     */
+
+	    height += txtHeight + butPtr->padY;
+	    width = (width > txtWidth ? width : txtWidth);
+	    break;
+	case COMPOUND_LEFT:
+	case COMPOUND_RIGHT:
+	    /*
+	     * Image is left or right of text.
+	     */
+
+	    width += txtWidth + butPtr->padX;
+	    height = (height > txtHeight ? height : txtHeight);
+	    break;
+	case COMPOUND_CENTER:
+	    /*
+	     * Image and text are superimposed.
+	     */
+
+	    width = (width > txtWidth ? width : txtWidth);
+	    height = (height > txtHeight ? height : txtHeight);
+	    break;
+	case COMPOUND_NONE:
+	    break;
 	}
 	if (butPtr->width > 0) {
 	    width = butPtr->width;
@@ -929,7 +942,6 @@ TkpComputeButtonGeometry(butPtr)
 
 	width += 2*butPtr->padX;
 	height += 2*butPtr->padY;
-
     } else {
 	if (haveImage) {
 	    if (butPtr->width > 0) {
@@ -938,7 +950,7 @@ TkpComputeButtonGeometry(butPtr)
 	    if (butPtr->height > 0) {
 		height = butPtr->height;
 	    }
-	    
+
 	    if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) {
 		butPtr->indicatorSpace = height;
 		if (butPtr->type == TYPE_CHECK_BUTTON) {
@@ -950,7 +962,7 @@ TkpComputeButtonGeometry(butPtr)
 	} else {
 	    width = txtWidth;
 	    height = txtHeight;
-	    
+
 	    if (butPtr->width > 0) {
 		width = butPtr->width * avgWidth;
 	    }
@@ -971,8 +983,8 @@ TkpComputeButtonGeometry(butPtr)
     /*
      * When issuing the geometry request, add extra space for the indicator,
      * if any, and for the border and padding, plus two extra pixels so the
-     * display can be offset by 1 pixel in either direction for the raised
-     * or lowered effect.
+     * display can be offset by 1 pixel in either direction for the raised or
+     * lowered effect.
      */
 
     if ((butPtr->image == NULL) && (butPtr->bitmap == None)) {
@@ -987,3 +999,11 @@ TkpComputeButtonGeometry(butPtr)
 	    + 2*butPtr->inset), (int) (height + 2*butPtr->inset));
     Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixDraw.c b/unix/tkUnixDraw.c
index 157da66..074bdad 100644
--- a/unix/tkUnixDraw.c
+++ b/unix/tkUnixDraw.c
@@ -1,14 +1,14 @@
-/* 
+/*
  * tkUnixDraw.c --
  *
  *	This file contains X specific drawing routines.
  *
  * Copyright (c) 1995 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: tkUnixDraw.c,v 1.8 2005/08/09 07:39:22 das Exp $
+ * RCS: @(#) $Id: tkUnixDraw.c,v 1.9 2005/11/14 11:54:21 dkf Exp $
  */
 
 #include "tkPort.h"
@@ -19,8 +19,8 @@
 #endif
 
 /*
- * The following structure is used to pass information to
- * ScrollRestrictProc from TkScrollWindow.
+ * The following structure is used to pass information to ScrollRestrictProc
+ * from TkScrollWindow.
  */
 
 typedef struct ScrollInfo {
@@ -32,46 +32,46 @@ typedef struct ScrollInfo {
 } ScrollInfo;
 
 /*
- * Forward declarations for procedures declared later in this file:
+ * Forward declarations for functions declared later in this file:
  */
 
-static Tk_RestrictAction	ScrollRestrictProc _ANSI_ARGS_((
-    				    ClientData arg, XEvent *eventPtr));
+static Tk_RestrictAction ScrollRestrictProc(ClientData arg, XEvent *eventPtr);
 
 /*
  *----------------------------------------------------------------------
  *
  * TkScrollWindow --
  *
- *	Scroll a rectangle of the specified window and accumulate
- *	damage information in the specified Region.
+ *	Scroll a rectangle of the specified window and accumulate damage
+ *	information in the specified Region.
  *
  * Results:
- *	Returns 0 if no damage additional damage was generated.  Sets
- *	damageRgn to contain the damaged areas and returns 1 if
- *	GraphicsExpose events were detected.
+ *	Returns 0 if no damage additional damage was generated. Sets damageRgn
+ *	to contain the damaged areas and returns 1 if GraphicsExpose events
+ *	were detected.
  *
  * Side effects:
- *	Scrolls the bits in the window and enters the event loop
- *	looking for damage events.
+ *	Scrolls the bits in the window and enters the event loop looking for
+ *	damage events.
  *
  *----------------------------------------------------------------------
  */
 
 int
-TkScrollWindow(tkwin, gc, x, y, width, height, dx, dy, damageRgn)
-    Tk_Window tkwin;		/* The window to be scrolled. */
-    GC gc;			/* GC for window to be scrolled. */
-    int x, y, width, height;	/* Position rectangle to be scrolled. */
-    int dx, dy;			/* Distance rectangle should be moved. */
-    TkRegion damageRgn;		/* Region to accumulate damage in. */
+TkScrollWindow(
+    Tk_Window tkwin,		/* The window to be scrolled. */
+    GC gc,			/* GC for window to be scrolled. */
+    int x, int y, int width, int height,
+				/* Position rectangle to be scrolled. */
+    int dx, int dy,		/* Distance rectangle should be moved. */
+    TkRegion damageRgn)		/* Region to accumulate damage in. */
 {
     Tk_RestrictProc *oldProc;
     ClientData oldArg, dummy;
     ScrollInfo info;
-    
+
     XCopyArea(Tk_Display(tkwin), Tk_WindowId(tkwin), Tk_WindowId(tkwin), gc,
-	    x, y, (unsigned int) width, (unsigned int) height, x + dx, y + dy);
+	    x, y, (unsigned) width, (unsigned) height, x+dx, y+dy);
 
     info.done = 0;
     info.window = Tk_WindowId(tkwin);
@@ -81,9 +81,9 @@ TkScrollWindow(tkwin, gc, x, y, width, height, dx, dy, damageRgn)
     info.dy = dy;
 
     /*
-     * Sync the event stream so all of the expose events will be on the
-     * Tk event queue before we start filtering.  This avoids busy waiting
-     * while we filter events.
+     * Sync the event stream so all of the expose events will be on the Tk
+     * event queue before we start filtering. This avoids busy waiting while
+     * we filter events.
      */
 
     TkpSync(info.display);
@@ -107,9 +107,9 @@ TkScrollWindow(tkwin, gc, x, y, width, height, dx, dy, damageRgn)
  * ScrollRestrictProc --
  *
  *	A Tk_RestrictProc used by TkScrollWindow to gather up Expose
- *	information into a single damage region.  It accumulates damage
- *	events on the specified window until a NoExpose or the last
- *	GraphicsExpose event is detected.
+ *	information into a single damage region. It accumulates damage events
+ *	on the specified window until a NoExpose or the last GraphicsExpose
+ *	event is detected.
  *
  * Results:
  *	None.
@@ -122,9 +122,9 @@ TkScrollWindow(tkwin, gc, x, y, width, height, dx, dy, damageRgn)
  */
 
 static Tk_RestrictAction
-ScrollRestrictProc(arg, eventPtr)
-    ClientData arg;
-    XEvent *eventPtr;
+ScrollRestrictProc(
+    ClientData arg,
+    XEvent *eventPtr)
 {
     ScrollInfo *info = (ScrollInfo *) arg;
     XRectangle rect;
@@ -152,13 +152,12 @@ ScrollRestrictProc(arg, eventPtr)
 	    info->done = 1;
 	}
     } else if (eventPtr->type == Expose) {
-
 	/*
-	 * This case is tricky.  This event was already queued before
-	 * the XCopyArea was issued.  If this area overlaps the area
-	 * being copied, then some of the copied area may be invalid.
-	 * The easiest way to handle this case is to mark both the
-	 * original area and the shifted area as damaged.
+	 * This case is tricky. This event was already queued before the
+	 * XCopyArea was issued. If this area overlaps the area being copied,
+	 * then some of the copied area may be invalid. The easiest way to
+	 * handle this case is to mark both the original area and the shifted
+	 * area as damaged.
 	 */
 
 	rect.x = eventPtr->xexpose.x;
@@ -182,30 +181,30 @@ ScrollRestrictProc(arg, eventPtr)
  *
  * TkpDrawHighlightBorder --
  *
- *	This procedure draws a rectangular ring around the outside of
- *	a widget to indicate that it has received the input focus.
+ *	This function draws a rectangular ring around the outside of a widget
+ *	to indicate that it has received the input focus.
  *
- *      On Unix, we just draw the simple inset ring.  On other sytems,
- *      e.g. the Mac, the focus ring is a little more complicated, so we
- *      need this abstraction.
+ *      On Unix, we just draw the simple inset ring. On other sytems, e.g. the
+ *      Mac, the focus ring is a little more complicated, so we need this
+ *      abstraction.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	A rectangle "width" pixels wide is drawn in "drawable",
- *	corresponding to the outer area of "tkwin".
+ *	A rectangle "width" pixels wide is drawn in "drawable", corresponding
+ *	to the outer area of "tkwin".
  *
  *----------------------------------------------------------------------
  */
 
-void 
-TkpDrawHighlightBorder(tkwin, fgGC, bgGC, highlightWidth, drawable)
-    Tk_Window tkwin;
-    GC fgGC;
-    GC bgGC;
-    int highlightWidth;
-    Drawable drawable;
+void
+TkpDrawHighlightBorder(
+    Tk_Window tkwin,
+    GC fgGC,
+    GC bgGC,
+    int highlightWidth,
+    Drawable drawable)
 {
     TkDrawInsetFocusHighlight(tkwin, fgGC, highlightWidth, drawable, 0);
 }
@@ -215,7 +214,7 @@ TkpDrawHighlightBorder(tkwin, fgGC, bgGC, highlightWidth, drawable)
  *
  * TkpDrawFrame --
  *
- *	This procedure draws the rectangular frame area.
+ *	This function draws the rectangular frame area.
  *
  * Results:
  *	None.
@@ -227,12 +226,22 @@ TkpDrawHighlightBorder(tkwin, fgGC, bgGC, highlightWidth, drawable)
  */
 
 void
-TkpDrawFrame (Tk_Window tkwin, Tk_3DBorder border,
-	int highlightWidth, int borderWidth, int relief)
+TkpDrawFrame(
+    Tk_Window tkwin,
+    Tk_3DBorder border,
+    int highlightWidth,
+    int borderWidth,
+    int relief)
 {
-    Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin),
-	    border, highlightWidth, highlightWidth,
-	    Tk_Width(tkwin) - 2 * highlightWidth,
-	    Tk_Height(tkwin) - 2 * highlightWidth,
-	    borderWidth, relief);
+    Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), border, highlightWidth,
+	    highlightWidth, Tk_Width(tkwin) - 2*highlightWidth,
+	    Tk_Height(tkwin) - 2*highlightWidth, borderWidth, relief);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixEmbed.c b/unix/tkUnixEmbed.c
index 40d54ad..a74ed83 100644
--- a/unix/tkUnixEmbed.c
+++ b/unix/tkUnixEmbed.c
@@ -1,17 +1,17 @@
-/* 
+/*
  * tkUnixEmbed.c --
  *
- *	This file contains platform-specific procedures for UNIX to provide
+ *	This file contains platform-specific functions for UNIX to provide
  *	basic operations needed for application embedding (where one
- *	application can use as its main window an internal window from
- *	some other application).
+ *	application can use as its main window an internal window from some
+ *	other application).
  *
  * Copyright (c) 1996-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: tkUnixEmbed.c,v 1.8 2005/01/09 18:28:06 chengyemao Exp $
+ * RCS: @(#) $Id: tkUnixEmbed.c,v 1.9 2005/11/14 11:54:21 dkf Exp $
  */
 
 #include "tkInt.h"
@@ -19,90 +19,87 @@
 
 /*
  * One of the following structures exists for each container in this
- * application.  It keeps track of the container window and its
- * associated embedded window.
+ * application. It keeps track of the container window and its associated
+ * embedded window.
  */
 
 typedef struct Container {
-    Window parent;			/* X's window id for the parent of
-					 * the pair (the container). */
-    Window parentRoot;			/* Id for the root window of parent's
-					 * screen. */
-    TkWindow *parentPtr;		/* Tk's information about the container,
-					 * or NULL if the container isn't
-					 * in this process. */
-    Window wrapper;			/* X's window id for the wrapper
-					 * window for the embedded window.
-					 * Starts off as None, but gets
-					 * filled in when the window is
-					 * eventually created. */
-    TkWindow *embeddedPtr;		/* Tk's information about the embedded
-					 * window, or NULL if the embedded
-					 * application isn't in this process.
-					 * Note that this is *not* the
-					 * same window as wrapper: wrapper is
-					 * the parent of embeddedPtr. */
-    struct Container *nextPtr;		/* Next in list of all containers in
-					 * this process. */
+    Window parent;		/* X's window id for the parent of the pair
+				 * (the container). */
+    Window parentRoot;		/* Id for the root window of parent's
+				 * screen. */
+    TkWindow *parentPtr;	/* Tk's information about the container, or
+				 * NULL if the container isn't in this
+				 * process. */
+    Window wrapper;		/* X's window id for the wrapper window for
+				 * the embedded window. Starts off as None,
+				 * but gets filled in when the window is
+				 * eventually created. */
+    TkWindow *embeddedPtr;	/* Tk's information about the embedded window,
+				 * or NULL if the embedded application isn't
+				 * in this process. Note that this is *not*
+				 * the same window as wrapper: wrapper is the
+				 * parent of embeddedPtr. */
+    struct Container *nextPtr;	/* Next in list of all containers in this
+				 * process. */
 } Container;
 
 typedef struct ThreadSpecificData {
-    Container *firstContainerPtr;       /* First in list of all containers
-					 * managed by this process.  */
+    Container *firstContainerPtr;
+				/* First in list of all containers managed by
+				 * this process. */
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
 /*
- * Prototypes for static procedures defined in this file:
+ * Prototypes for static functions defined in this file:
  */
 
-static void		ContainerEventProc _ANSI_ARGS_((
-			    ClientData clientData, XEvent *eventPtr));
-static void		EmbeddedEventProc _ANSI_ARGS_((
-			    ClientData clientData, XEvent *eventPtr));
-static int		EmbedErrorProc _ANSI_ARGS_((ClientData clientData,
-			    XErrorEvent *errEventPtr));
-static void		EmbedFocusProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static void		EmbedGeometryRequest _ANSI_ARGS_((
-			    Container * containerPtr, int width, int height));
-static void		EmbedSendConfigure _ANSI_ARGS_((
-			    Container *containerPtr));
-static void		EmbedStructureProc _ANSI_ARGS_((ClientData clientData,
-			    XEvent *eventPtr));
-static void		EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr));
+static void		ContainerEventProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		EmbeddedEventProc(ClientData clientData,
+			    XEvent *eventPtr);
+static int		EmbedErrorProc(ClientData clientData,
+			    XErrorEvent *errEventPtr);
+static void		EmbedFocusProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		EmbedGeometryRequest(Container *containerPtr,
+			    int width, int height);
+static void		EmbedSendConfigure(Container *containerPtr);
+static void		EmbedStructureProc(ClientData clientData,
+			    XEvent *eventPtr);
+static void		EmbedWindowDeleted(TkWindow *winPtr);
 
 /*
  *----------------------------------------------------------------------
  *
  * TkpUseWindow --
  *
- *	This procedure causes a Tk window to use a given X window as
- *	its parent window, rather than the root window for the screen.
- *	It is invoked by an embedded application to specify the window
- *	in which it is embedded.
+ *	This function causes a Tk window to use a given X window as its parent
+ *	window, rather than the root window for the screen. It is invoked by
+ *	an embedded application to specify the window in which it is embedded.
  *
  * Results:
- *	The return value is normally TCL_OK.  If an error occurs (such
- *	as string not being a valid window spec), then the return value
- *	is TCL_ERROR and an error message is left in the interp's result if
+ *	The return value is normally TCL_OK. If an error occurs (such as
+ *	string not being a valid window spec), then the return value is
+ *	TCL_ERROR and an error message is left in the interp's result if
  *	interp is non-NULL.
  *
  * Side effects:
- *	Changes the colormap and other visual information to match that
- *	of the parent window given by "string".
+ *	Changes the colormap and other visual information to match that of the
+ *	parent window given by "string".
  *
  *----------------------------------------------------------------------
  */
 
 int
-TkpUseWindow(interp, tkwin, string)
-    Tcl_Interp *interp;		/* If not NULL, used for error reporting
-				 * if string is bogus. */
-    Tk_Window tkwin;		/* Tk window that does not yet have an
+TkpUseWindow(
+    Tcl_Interp *interp,		/* If not NULL, used for error reporting if
+				 * string is bogus. */
+    Tk_Window tkwin,		/* Tk window that does not yet have an
 				 * associated X window. */
-    CONST char *string;		/* String identifying an X window to use
-				 * for tkwin;  must be an integer value. */
+    CONST char *string)		/* String identifying an X window to use for
+				 * tkwin; must be an integer value. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     TkWindow *usePtr;
@@ -111,11 +108,12 @@ TkpUseWindow(interp, tkwin, string)
     Tk_ErrorHandler handler;
     Container *containerPtr;
     XWindowAttributes parentAtts;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if (winPtr->window != None) {
-	Tcl_AppendResult(interp, "can't modify container after widget is created", (char *) NULL);
+	Tcl_AppendResult(interp,
+		"can't modify container after widget is created", NULL);
 	return TCL_ERROR;
     }
     if (Tcl_GetInt(interp, string, &id) != TCL_OK) {
@@ -127,30 +125,30 @@ TkpUseWindow(interp, tkwin, string)
     if (usePtr != NULL) {
 	if (!(usePtr->flags & TK_CONTAINER)) {
 	    Tcl_AppendResult(interp, "window \"", usePtr->pathName,
-                    "\" doesn't have -container option set", (char *) NULL);
+                    "\" doesn't have -container option set", NULL);
 	    return TCL_ERROR;
 	}
     }
 
     /*
      * Tk sets the window colormap to the screen default colormap in
-     * tkWindow.c:AllocWindow. This doesn't work well for embedded
-     * windows. So we override the colormap and visual settings to be
-     * the same as the parent window (which is in the container app).
+     * tkWindow.c:AllocWindow. This doesn't work well for embedded windows. So
+     * we override the colormap and visual settings to be the same as the
+     * parent window (which is in the container app).
      */
 
     anyError = 0;
     handler = Tk_CreateErrorHandler(winPtr->display, -1, -1, -1,
 	    EmbedErrorProc, (ClientData) &anyError);
     if (!XGetWindowAttributes(winPtr->display, parent, &parentAtts)) {
-        anyError =  1;
+        anyError = 1;
     }
     XSync(winPtr->display, False);
     Tk_DeleteErrorHandler(handler);
     if (anyError) {
 	if (interp != NULL) {
 	    Tcl_AppendResult(interp, "couldn't create child of window \"",
-		    string, "\"", (char *) NULL);
+		    string, "\"", NULL);
 	}
 	return TCL_ERROR;
     }
@@ -158,18 +156,18 @@ TkpUseWindow(interp, tkwin, string)
 	    parentAtts.colormap);
 
     /*
-     * Create an event handler to clean up the Container structure when
-     * tkwin is eventually deleted.
+     * Create an event handler to clean up the Container structure when tkwin
+     * is eventually deleted.
      */
 
     Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc,
 	    (ClientData) winPtr);
 
     /*
-     * Save information about the container and the embedded window
-     * in a Container structure.  If there is already an existing
-     * Container structure, it means that both container and embedded
-     * app. are in the same process.
+     * Save information about the container and the embedded window in a
+     * Container structure. If there is already an existing Container
+     * structure, it means that both container and embedded app. are in the
+     * same process.
      */
 
     for (containerPtr = tsdPtr->firstContainerPtr; containerPtr != NULL;
@@ -199,8 +197,8 @@ TkpUseWindow(interp, tkwin, string)
  *
  * TkpMakeWindow --
  *
- *	Create an actual window system window object based on the
- *	current attributes of the specified TkWindow.
+ *	Create an actual window system window object based on the current
+ *	attributes of the specified TkWindow.
  *
  * Results:
  *	Returns the handle to the new window, or None on failure.
@@ -212,22 +210,22 @@ TkpUseWindow(interp, tkwin, string)
  */
 
 Window
-TkpMakeWindow(winPtr, parent)
-    TkWindow *winPtr;		/* Tk's information about the window that
-				 * is to be instantiated. */
-    Window parent;		/* Window system token for the parent in
-				 * which the window is to be created. */
+TkpMakeWindow(
+    TkWindow *winPtr,		/* Tk's information about the window that is
+				 * to be instantiated. */
+    Window parent)		/* Window system token for the parent in which
+				 * the window is to be created. */
 {
     Container *containerPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if (winPtr->flags & TK_EMBEDDED) {
 	/*
-	 * This window is embedded.  Don't create the new window in the
-	 * given parent; instead, create it as a child of the root window
-	 * of the container's screen.  The window will get reparented
-	 * into a wrapper window later.
+	 * This window is embedded. Don't create the new window in the given
+	 * parent; instead, create it as a child of the root window of the
+	 * container's screen. The window will get reparented into a wrapper
+	 * window later.
 	 */
 
 	for (containerPtr = tsdPtr->firstContainerPtr; ;
@@ -255,10 +253,9 @@ TkpMakeWindow(winPtr, parent)
  *
  * TkpMakeContainer --
  *
- *	This procedure is called to indicate that a particular window
- *	will be a container for an embedded application.  This changes
- *	certain aspects of the window's behavior, such as whether it
- *	will receive events anymore.
+ *	This function is called to indicate that a particular window will be a
+ *	container for an embedded application. This changes certain aspects of
+ *	the window's behavior, such as whether it will receive events anymore.
  *
  * Results:
  *	None.
@@ -270,18 +267,18 @@ TkpMakeWindow(winPtr, parent)
  */
 
 void
-TkpMakeContainer(tkwin)
-    Tk_Window tkwin;		/* Token for a window that is about to
-				 * become a container. */
+TkpMakeContainer(
+    Tk_Window tkwin)		/* Token for a window that is about to become
+				 * a container. */
 {
     TkWindow *winPtr = (TkWindow *) tkwin;
     Container *containerPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     /*
-     * Register the window as a container so that, for example, we can
-     * find out later if the embedded app. is in the same process.
+     * Register the window as a container so that, for example, we can find
+     * out later if the embedded app. is in the same process.
      */
 
     Tk_MakeWindowExist(tkwin);
@@ -296,10 +293,10 @@ TkpMakeContainer(tkwin)
     winPtr->flags |= TK_CONTAINER;
 
     /*
-     * Request SubstructureNotify events so that we can find out when
-     * the embedded application creates its window or attempts to
-     * resize it.  Also watch Configure events on the container so that
-     * we can resize the child to match.
+     * Request SubstructureNotify events so that we can find out when the
+     * embedded application creates its window or attempts to resize it. Also
+     * watch Configure events on the container so that we can resize the child
+     * to match.
      */
 
     winPtr->atts.event_mask |= SubstructureRedirectMask|SubstructureNotifyMask;
@@ -318,12 +315,11 @@ TkpMakeContainer(tkwin)
  *
  * EmbedErrorProc --
  *
- *	This procedure is invoked if an error occurs while creating
- *	an embedded window.
+ *	This function is invoked if an error occurs while creating an embedded
+ *	window.
  *
  * Results:
- *	Always returns 0 to indicate that the error has been properly
- *	handled.
+ *	Always returns 0 to indicate that the error has been properly handled.
  *
  * Side effects:
  *	The integer pointed to by the clientData argument is set to 1.
@@ -332,10 +328,10 @@ TkpMakeContainer(tkwin)
  */
 
 static int
-EmbedErrorProc(clientData, errEventPtr)
-    ClientData clientData;	/* Points to integer to set. */
-    XErrorEvent *errEventPtr;	/* Points to information about error
-				 * (not used). */
+EmbedErrorProc(
+    ClientData clientData,	/* Points to integer to set. */
+    XErrorEvent *errEventPtr)	/* Points to information about error (not
+				 * used). */
 {
     int *iPtr = (int *) clientData;
 
@@ -348,9 +344,9 @@ EmbedErrorProc(clientData, errEventPtr)
  *
  * EmbeddedEventProc --
  *
- *	This procedure is invoked by the Tk event dispatcher when various
- *	useful events are received for a window that is embedded in
- *	another application.
+ *	This function is invoked by the Tk event dispatcher when various
+ *	useful events are received for a window that is embedded in another
+ *	application.
  *
  * Results:
  *	None.
@@ -363,9 +359,9 @@ EmbedErrorProc(clientData, errEventPtr)
  */
 
 static void
-EmbeddedEventProc(clientData, eventPtr)
-    ClientData clientData;		/* Token for container window. */
-    XEvent *eventPtr;			/* ResizeRequest event. */
+EmbeddedEventProc(
+    ClientData clientData,	/* Token for container window. */
+    XEvent *eventPtr)		/* ResizeRequest event. */
 {
     TkWindow *winPtr = (TkWindow *) clientData;
 
@@ -379,40 +375,40 @@ EmbeddedEventProc(clientData, eventPtr)
  *
  * ContainerEventProc --
  *
- *	This procedure is invoked by the Tk event dispatcher when various
- *	useful events are received for the children of a container
- *	window.  It forwards relevant information, such as geometry
- *	requests, from the events into the container's application.
+ *	This function is invoked by the Tk event dispatcher when various
+ *	useful events are received for the children of a container window. It
+ *	forwards relevant information, such as geometry requests, from the
+ *	events into the container's application.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Depends on the event.  For example, when ConfigureRequest events
- *	occur, geometry information gets set for the container window.
+ *	Depends on the event. For example, when ConfigureRequest events occur,
+ *	geometry information gets set for the container window.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ContainerEventProc(clientData, eventPtr)
-    ClientData clientData;		/* Token for container window. */
-    XEvent *eventPtr;			/* ResizeRequest event. */
+ContainerEventProc(
+    ClientData clientData,	/* Token for container window. */
+    XEvent *eventPtr)		/* ResizeRequest event. */
 {
     TkWindow *winPtr = (TkWindow *) clientData;
     Container *containerPtr;
     Tk_ErrorHandler errHandler;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     /*
-     * Ignore any X protocol errors that happen in this procedure
-     * (almost any operation could fail, for example, if the embedded
-     * application has deleted its window).
+     * Ignore any X protocol errors that happen in this function (almost any
+     * operation could fail, for example, if the embedded application has
+     * deleted its window).
      */
 
     errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
-	    -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+	    -1, -1, NULL, (ClientData) NULL);
 
     /*
      * Find the Container structure associated with the parent window.
@@ -428,31 +424,28 @@ ContainerEventProc(clientData, eventPtr)
 
     if (eventPtr->type == CreateNotify) {
 	/*
-	 * A new child window has been created in the container. Record
-	 * its id in the Container structure (if more than one child is
-	 * created, just remember the last one and ignore the earlier
-	 * ones).  Also set the child's size to match the container.
+	 * A new child window has been created in the container. Record its id
+	 * in the Container structure (if more than one child is created, just
+	 * remember the last one and ignore the earlier ones). Also set the
+	 * child's size to match the container.
 	 */
 
 	containerPtr->wrapper = eventPtr->xcreatewindow.window;
 	XMoveResizeWindow(eventPtr->xcreatewindow.display,
 		containerPtr->wrapper, 0, 0,
-		(unsigned int) Tk_Width(
-			(Tk_Window) containerPtr->parentPtr),
-		(unsigned int) Tk_Height(
-			(Tk_Window) containerPtr->parentPtr));
+		(unsigned) Tk_Width((Tk_Window) containerPtr->parentPtr),
+		(unsigned) Tk_Height((Tk_Window) containerPtr->parentPtr));
     } else if (eventPtr->type == ConfigureRequest) {
 	if ((eventPtr->xconfigurerequest.x != 0)
 		|| (eventPtr->xconfigurerequest.y != 0)) {
 	    /*
-	     * The embedded application is trying to move itself, which
-	     * isn't legal.  At this point, the window hasn't actually
-	     * moved, but we need to send it a ConfigureNotify event to
-	     * let it know that its request has been denied.  If the
-	     * embedded application was also trying to resize itself, a
-	     * ConfigureNotify will be sent by the geometry management
-	     * code below, so we don't need to do anything.  Otherwise,
-	     * generate a synthetic event.
+	     * The embedded application is trying to move itself, which isn't
+	     * legal. At this point, the window hasn't actually moved, but we
+	     * need to send it a ConfigureNotify event to let it know that its
+	     * request has been denied. If the embedded application was also
+	     * trying to resize itself, a ConfigureNotify will be sent by the
+	     * geometry management code below, so we don't need to do
+	     * anything. Otherwise, generate a synthetic event.
 	     */
 
 	    if ((eventPtr->xconfigurerequest.width == winPtr->changes.width)
@@ -467,15 +460,15 @@ ContainerEventProc(clientData, eventPtr)
     } else if (eventPtr->type == MapRequest) {
 	/*
 	 * The embedded application's map request was ignored and simply
-	 * passed on to us, so we have to map the window for it to appear
-	 * on the screen.
+	 * passed on to us, so we have to map the window for it to appear on
+	 * the screen.
 	 */
 
 	XMapWindow(eventPtr->xmaprequest.display,
 		eventPtr->xmaprequest.window);
     } else if (eventPtr->type == DestroyNotify) {
 	/*
-	 * The embedded application is gone.  Destroy the container window.
+	 * The embedded application is gone. Destroy the container window.
 	 */
 
 	Tk_DestroyWindow((Tk_Window) winPtr);
@@ -488,11 +481,10 @@ ContainerEventProc(clientData, eventPtr)
  *
  * EmbedStructureProc --
  *
- *	This procedure is invoked by the Tk event dispatcher when
- *	a container window owned by this application gets resized
- *	(and also at several other times that we don't care about).
- *	This procedure reflects the size change in the embedded
- *	window that corresponds to the container.
+ *	This function is invoked by the Tk event dispatcher when a container
+ *	window owned by this application gets resized (and also at several
+ *	other times that we don't care about). This function reflects the size
+ *	change in the embedded window that corresponds to the container.
  *
  * Results:
  *	None.
@@ -504,9 +496,9 @@ ContainerEventProc(clientData, eventPtr)
  */
 
 static void
-EmbedStructureProc(clientData, eventPtr)
-    ClientData clientData;		/* Token for container window. */
-    XEvent *eventPtr;			/* ResizeRequest event. */
+EmbedStructureProc(
+    ClientData clientData,	/* Token for container window. */
+    XEvent *eventPtr)		/* ResizeRequest event. */
 {
     Container *containerPtr = (Container *) clientData;
     Tk_ErrorHandler errHandler;
@@ -519,13 +511,11 @@ EmbedStructureProc(clientData, eventPtr)
 	     */
 
 	    errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
-		    -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+		    -1, -1, NULL, (ClientData) NULL);
 	    XMoveResizeWindow(eventPtr->xconfigure.display,
 		    containerPtr->wrapper, 0, 0,
-		    (unsigned int) Tk_Width(
-			    (Tk_Window) containerPtr->parentPtr),
-		    (unsigned int) Tk_Height(
-			    (Tk_Window) containerPtr->parentPtr));
+		    (unsigned) Tk_Width((Tk_Window) containerPtr->parentPtr),
+		    (unsigned) Tk_Height((Tk_Window) containerPtr->parentPtr));
 	    Tk_DeleteErrorHandler(errHandler);
 	}
     } else if (eventPtr->type == DestroyNotify) {
@@ -538,11 +528,10 @@ EmbedStructureProc(clientData, eventPtr)
  *
  * EmbedFocusProc --
  *
- *	This procedure is invoked by the Tk event dispatcher when
- *	FocusIn and FocusOut events occur for a container window owned
- *	by this application.  It is responsible for moving the focus
- *	back and forth between a container application and an embedded
- *	application.
+ *	This function is invoked by the Tk event dispatcher when FocusIn and
+ *	FocusOut events occur for a container window owned by this
+ *	application. It is responsible for moving the focus back and forth
+ *	between a container application and an embedded application.
  *
  * Results:
  *	None.
@@ -554,9 +543,9 @@ EmbedStructureProc(clientData, eventPtr)
  */
 
 static void
-EmbedFocusProc(clientData, eventPtr)
-    ClientData clientData;		/* Token for container window. */
-    XEvent *eventPtr;			/* ResizeRequest event. */
+EmbedFocusProc(
+    ClientData clientData,	/* Token for container window. */
+    XEvent *eventPtr)		/* ResizeRequest event. */
 {
     Container *containerPtr = (Container *) clientData;
     Tk_ErrorHandler errHandler;
@@ -565,15 +554,15 @@ EmbedFocusProc(clientData, eventPtr)
     display = Tk_Display(containerPtr->parentPtr);
     if (eventPtr->type == FocusIn) {
 	/*
-	 * The focus just arrived at the container.  Change the X focus
-	 * to move it to the embedded application, if there is one. 
-	 * Ignore X errors that occur during this operation (it's
-	 * possible that the new focus window isn't mapped).
+	 * The focus just arrived at the container. Change the X focus to move
+	 * it to the embedded application, if there is one. Ignore X errors
+	 * that occur during this operation (it's possible that the new focus
+	 * window isn't mapped).
 	 */
-    
+
 	if (containerPtr->wrapper != None) {
 	    errHandler = Tk_CreateErrorHandler(eventPtr->xfocus.display, -1,
-		    -1, -1, (Tk_ErrorProc *) NULL, (ClientData) NULL);
+		    -1, -1, NULL, (ClientData) NULL);
 	    XSetInputFocus(display, containerPtr->wrapper, RevertToParent,
 		    CurrentTime);
 	    Tk_DeleteErrorHandler(errHandler);
@@ -586,38 +575,38 @@ EmbedFocusProc(clientData, eventPtr)
  *
  * EmbedGeometryRequest --
  *
- *	This procedure is invoked when an embedded application requests
- *	a particular size.  It processes the request (which may or may
- *	not actually honor the request) and reflects the results back
- *	to the embedded application.
+ *	This function is invoked when an embedded application requests a
+ *	particular size. It processes the request (which may or may not
+ *	actually honor the request) and reflects the results back to the
+ *	embedded application.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	If we deny the child's size change request, a Configure event
- *	is synthesized to let the child know how big it ought to be.
- *	Events get processed while we're waiting for the geometry
- *	managers to do their thing.
+ *	If we deny the child's size change request, a Configure event is
+ *	synthesized to let the child know how big it ought to be. Events get
+ *	processed while we're waiting for the geometry managers to do their
+ *	thing.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-EmbedGeometryRequest(containerPtr, width, height)
-    Container *containerPtr;	/* Information about the embedding. */
-    int width, height;		/* Size that the child has requested. */
+EmbedGeometryRequest(
+    Container *containerPtr,	/* Information about the embedding. */
+    int width, int height)	/* Size that the child has requested. */
 {
     TkWindow *winPtr = containerPtr->parentPtr;
 
     /*
-     * Forward the requested size into our geometry management hierarchy
-     * via the container window.  We need to send a Configure event back
-     * to the embedded application if we decide not to honor its
-     * request; to make this happen, process all idle event handlers
-     * synchronously here (so that the geometry managers have had a
-     * chance to do whatever they want to do), and if the window's size
-     * didn't change then generate a configure event.
+     * Forward the requested size into our geometry management hierarchy via
+     * the container window. We need to send a Configure event back to the
+     * embedded application if we decide not to honor its request; to make
+     * this happen, process all idle event handlers synchronously here (so
+     * that the geometry managers have had a chance to do whatever they want
+     * to do), and if the window's size didn't change then generate a
+     * configure event.
      */
 
     Tk_GeometryRequest((Tk_Window) winPtr, width, height);
@@ -635,11 +624,11 @@ EmbedGeometryRequest(containerPtr, width, height)
  *
  * EmbedSendConfigure --
  *
- *	This procedure synthesizes a ConfigureNotify event to notify an
- *	embedded application of its current size and location.  This
- *	procedure is called when the embedded application made a
- *	geometry request that we did not grant, so that the embedded
- *	application knows that its geometry didn't change after all.
+ *	This function synthesizes a ConfigureNotify event to notify an
+ *	embedded application of its current size and location. This function
+ *	is called when the embedded application made a geometry request that
+ *	we did not grant, so that the embedded application knows that its
+ *	geometry didn't change after all.
  *
  * Results:
  *	None.
@@ -651,15 +640,14 @@ EmbedGeometryRequest(containerPtr, width, height)
  */
 
 static void
-EmbedSendConfigure(containerPtr)
-    Container *containerPtr;	/* Information about the embedding. */
+EmbedSendConfigure(
+    Container *containerPtr)	/* Information about the embedding. */
 {
     TkWindow *winPtr = containerPtr->parentPtr;
     XEvent event;
 
     event.xconfigure.type = ConfigureNotify;
-    event.xconfigure.serial =
-	    LastKnownRequestProcessed(winPtr->display);
+    event.xconfigure.serial = LastKnownRequestProcessed(winPtr->display);
     event.xconfigure.send_event = True;
     event.xconfigure.display = winPtr->display;
     event.xconfigure.event = containerPtr->wrapper;
@@ -672,24 +660,23 @@ EmbedSendConfigure(containerPtr)
     event.xconfigure.override_redirect = False;
 
     /*
-     * Note:  when sending the event below, the ButtonPressMask
-     * causes the event to be sent only to applications that have
-     * selected for ButtonPress events, which should be just the
-     * embedded application.
+     * Note: when sending the event below, the ButtonPressMask causes the
+     * event to be sent only to applications that have selected for
+     * ButtonPress events, which should be just the embedded application.
      */
 
     XSendEvent(winPtr->display, containerPtr->wrapper, False,
 	    0, &event);
 
     /*
-     * The following needs to be done if the embedded window is
-     * not in the same application as the container window.
+     * The following needs to be done if the embedded window is not in the
+     * same application as the container window.
      */
 
     if (containerPtr->embeddedPtr == NULL) {
 	XMoveResizeWindow(winPtr->display, containerPtr->wrapper, 0, 0,
-	    (unsigned int) winPtr->changes.width,
-	    (unsigned int) winPtr->changes.height);
+		(unsigned) winPtr->changes.width,
+		(unsigned) winPtr->changes.height);
     }
 }
 
@@ -698,13 +685,13 @@ EmbedSendConfigure(containerPtr)
  *
  * TkpGetOtherWindow --
  *
- *	If both the container and embedded window are in the same
- *	process, this procedure will return either one, given the other.
+ *	If both the container and embedded window are in the same process,
+ *	this function will return either one, given the other.
  *
  * Results:
  *	If winPtr is a container, the return value is the token for the
- *	embedded window, and vice versa.  If the "other" window isn't in
- *	this process, NULL is returned.
+ *	embedded window, and vice versa. If the "other" window isn't in this
+ *	process, NULL is returned.
  *
  * Side effects:
  *	None.
@@ -713,15 +700,15 @@ EmbedSendConfigure(containerPtr)
  */
 
 TkWindow *
-TkpGetOtherWindow(winPtr)
-    TkWindow *winPtr;		/* Tk's structure for a container or
-				 * embedded window. */
+TkpGetOtherWindow(
+    TkWindow *winPtr)		/* Tk's structure for a container or embedded
+				 * window. */
 {
     Container *containerPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
-    for (containerPtr = tsdPtr->firstContainerPtr; 
+    for (containerPtr = tsdPtr->firstContainerPtr;
             containerPtr != NULL;
 	    containerPtr = containerPtr->nextPtr) {
 	if (containerPtr->embeddedPtr == winPtr) {
@@ -739,13 +726,13 @@ TkpGetOtherWindow(winPtr)
  *
  * TkpRedirectKeyEvent --
  *
- *	This procedure is invoked when a key press or release event
- *	arrives for an application that does not believe it owns the
- *	input focus.  This can happen because of embedding; for example,
- *	X can send an event to an embedded application when the real
- *	focus window is in the container application and is an ancestor
- *	of the container.  This procedure's job is to forward the event
- *	back to the application where it really belongs.
+ *	This function is invoked when a key press or release event arrives for
+ *	an application that does not believe it owns the input focus. This can
+ *	happen because of embedding; for example, X can send an event to an
+ *	embedded application when the real focus window is in the container
+ *	application and is an ancestor of the container. This function's job
+ *	is to forward the event back to the application where it really
+ *	belongs.
  *
  * Results:
  *	None.
@@ -757,15 +744,15 @@ TkpGetOtherWindow(winPtr)
  */
 
 void
-TkpRedirectKeyEvent(winPtr, eventPtr)
-    TkWindow *winPtr;		/* Window to which the event was originally
+TkpRedirectKeyEvent(
+    TkWindow *winPtr,		/* Window to which the event was originally
 				 * reported. */
-    XEvent *eventPtr;		/* X event to redirect (should be KeyPress
-				 * or KeyRelease). */
+    XEvent *eventPtr)		/* X event to redirect (should be KeyPress or
+				 * KeyRelease). */
 {
     Container *containerPtr;
     Window saved;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     /*
@@ -775,8 +762,8 @@ TkpRedirectKeyEvent(winPtr, eventPtr)
     while (1) {
 	if (winPtr == NULL) {
 	    /*
-	     * This window is being deleted.  This is too confusing a
-	     * case to handle so discard the event.
+	     * This window is being deleted. This is too confusing a case to
+	     * handle so discard the event.
 	     */
 
 	    return;
@@ -789,10 +776,10 @@ TkpRedirectKeyEvent(winPtr, eventPtr)
 
     if (winPtr->flags & TK_EMBEDDED) {
 	/*
-	 * This application is embedded.  If we got a key event without
-	 * officially having the focus, it means that the focus is
-	 * really in the container, but the mouse was over the embedded
-	 * application.  Send the event back to the container.
+	 * This application is embedded. If we got a key event without
+	 * officially having the focus, it means that the focus is really in
+	 * the container, but the mouse was over the embedded application.
+	 * Send the event back to the container.
 	 */
 
 	for (containerPtr = tsdPtr->firstContainerPtr;
@@ -803,7 +790,7 @@ TkpRedirectKeyEvent(winPtr, eventPtr)
 	saved = eventPtr->xkey.window;
 	eventPtr->xkey.window = containerPtr->parent;
 	XSendEvent(eventPtr->xkey.display, eventPtr->xkey.window, False,
-	    KeyPressMask|KeyReleaseMask, eventPtr);
+		KeyPressMask|KeyReleaseMask, eventPtr);
 	eventPtr->xkey.window = saved;
     }
 }
@@ -813,10 +800,10 @@ TkpRedirectKeyEvent(winPtr, eventPtr)
  *
  * TkpClaimFocus --
  *
- *	This procedure is invoked when someone asks or the input focus
- *	to be put on a window in an embedded application, but the
- *	application doesn't currently have the focus.  It requests the
- *	input focus from the container application.
+ *	This function is invoked when someone asks or the input focus to be
+ *	put on a window in an embedded application, but the application
+ *	doesn't currently have the focus. It requests the input focus from the
+ *	container application.
  *
  * Results:
  *	None.
@@ -828,16 +815,16 @@ TkpRedirectKeyEvent(winPtr, eventPtr)
  */
 
 void
-TkpClaimFocus(topLevelPtr, force)
-    TkWindow *topLevelPtr;		/* Top-level window containing desired
-					 * focus window; should be embedded. */
-    int force;				/* One means that the container should
-					 * claim the focus if it doesn't
-					 * currently have it. */
+TkpClaimFocus(
+    TkWindow *topLevelPtr,	/* Top-level window containing desired focus
+				 * window; should be embedded. */
+    int force)			/* One means that the container should claim
+				 * the focus if it doesn't currently have
+				 * it. */
 {
     XEvent event;
     Container *containerPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if (!(topLevelPtr->flags & TK_EMBEDDED)) {
@@ -865,9 +852,8 @@ TkpClaimFocus(topLevelPtr, force)
  *
  * TkpTestembedCmd --
  *
- *	This procedure implements the "testembed" command.  It returns
- *	some or all of the information in the list pointed to by
- *	firstContainerPtr.
+ *	This function implements the "testembed" command. It returns some or
+ *	all of the information in the list pointed to by firstContainerPtr.
  *
  * Results:
  *	A standard Tcl result.
@@ -879,17 +865,17 @@ TkpClaimFocus(topLevelPtr, force)
  */
 
 int
-TkpTestembedCmd(clientData, interp, argc, argv)
-    ClientData clientData;		/* Main window for application. */
-    Tcl_Interp *interp;			/* Current interpreter. */
-    int argc;				/* Number of arguments. */
-    CONST char **argv;			/* Argument strings. */
+TkpTestembedCmd(
+    ClientData clientData,	/* Main window for application. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int argc,			/* Number of arguments. */
+    CONST char **argv)		/* Argument strings. */
 {
     int all;
     Container *containerPtr;
     Tcl_DString dString;
     char buffer[50];
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     if ((argc > 1) && (strcmp(argv[1], "all") == 0)) {
@@ -903,13 +889,11 @@ TkpTestembedCmd(clientData, interp, argc, argv)
 	Tcl_DStringStartSublist(&dString);
 	if (containerPtr->parent == None) {
 	    Tcl_DStringAppendElement(&dString, "");
+	} else if (all) {
+	    sprintf(buffer, "0x%x", (int) containerPtr->parent);
+	    Tcl_DStringAppendElement(&dString, buffer);
 	} else {
-	    if (all) {
-		sprintf(buffer, "0x%x", (int) containerPtr->parent);
-		Tcl_DStringAppendElement(&dString, buffer);
-	    } else {
-		Tcl_DStringAppendElement(&dString, "XXX");
-	    }
+	    Tcl_DStringAppendElement(&dString, "XXX");
 	}
 	if (containerPtr->parentPtr == NULL) {
 	    Tcl_DStringAppendElement(&dString, "");
@@ -919,13 +903,11 @@ TkpTestembedCmd(clientData, interp, argc, argv)
 	}
 	if (containerPtr->wrapper == None) {
 	    Tcl_DStringAppendElement(&dString, "");
+	} else if (all) {
+	    sprintf(buffer, "0x%x", (int) containerPtr->wrapper);
+	    Tcl_DStringAppendElement(&dString, buffer);
 	} else {
-	    if (all) {
-		sprintf(buffer, "0x%x", (int) containerPtr->wrapper);
-		Tcl_DStringAppendElement(&dString, buffer);
-	    } else {
-		Tcl_DStringAppendElement(&dString, "XXX");
-	    }
+	    Tcl_DStringAppendElement(&dString, "XXX");
 	}
 	if (containerPtr->embeddedPtr == NULL) {
 	    Tcl_DStringAppendElement(&dString, "");
@@ -944,9 +926,9 @@ TkpTestembedCmd(clientData, interp, argc, argv)
  *
  * EmbedWindowDeleted --
  *
- *	This procedure is invoked when a window involved in embedding
- *	(as either the container or the embedded application) is
- *	destroyed.  It cleans up the Container structure for the window.
+ *	This function is invoked when a window involved in embedding (as
+ *	either the container or the embedded application) is destroyed. It
+ *	cleans up the Container structure for the window.
  *
  * Results:
  *	None.
@@ -958,16 +940,16 @@ TkpTestembedCmd(clientData, interp, argc, argv)
  */
 
 static void
-EmbedWindowDeleted(winPtr)
-    TkWindow *winPtr;		/* Tk's information about window that
-				 * was deleted. */
+EmbedWindowDeleted(
+    TkWindow *winPtr)		/* Tk's information about window that was
+				 * deleted. */
 {
     Container *containerPtr, *prevPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     /*
-     * Find the Container structure for this window work.  Delete the
+     * Find the Container structure for this window work. Delete the
      * information about the embedded application and free the container's
      * record.
      */
@@ -1003,12 +985,12 @@ EmbedWindowDeleted(winPtr)
  *
  * TkUnixContainerId --
  *
- *	Given an embedded window, this procedure returns the X window
+ *	Given an embedded window, this function returns the X window
  *	identifier for the associated container window.
  *
  * Results:
- *	The return value is the X window identifier for winPtr's
- *	container window.
+ *	The return value is the X window identifier for winPtr's container
+ *	window.
  *
  * Side effects:
  *	None.
@@ -1017,14 +999,14 @@ EmbedWindowDeleted(winPtr)
  */
 
 Window
-TkUnixContainerId(winPtr)
-    TkWindow *winPtr;		/* Tk's structure for an embedded window. */
+TkUnixContainerId(
+    TkWindow *winPtr)		/* Tk's structure for an embedded window. */
 {
     Container *containerPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
-    for (containerPtr = tsdPtr->firstContainerPtr; 
+    for (containerPtr = tsdPtr->firstContainerPtr;
             containerPtr != NULL; containerPtr = containerPtr->nextPtr) {
 	if (containerPtr->embeddedPtr == winPtr) {
 	    return containerPtr->parent;
@@ -1033,3 +1015,11 @@ TkUnixContainerId(winPtr)
     Tcl_Panic("TkUnixContainerId couldn't find window");
     return None;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixFont.c b/unix/tkUnixFont.c
index 34d814d..f392c9b 100644
--- a/unix/tkUnixFont.c
+++ b/unix/tkUnixFont.c
@@ -1,17 +1,17 @@
 /*
  * tkUnixFont.c --
  *
- *	Contains the Unix implementation of the platform-independant
- *	font package interface.
+ *	Contains the Unix implementation of the platform-independent font
+ *	package interface.
  *
  * Copyright (c) 1996-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: tkUnixFont.c,v 1.23 2005/04/14 22:39:34 hobbs Exp $
+ * RCS: @(#) $Id: tkUnixFont.c,v 1.24 2005/11/14 11:54:21 dkf Exp $
  */
- 
+
 #include "tkUnixInt.h"
 #include "tkFont.h"
 #include <netinet/in.h>		/* for htons() prototype */
@@ -26,15 +26,15 @@ static CONST char *encodingList[] = {
 };
 
 /*
- * The following structure represents a font family.  It is assumed that
- * all screen fonts constructed from the same "font family" share certain
- * properties; all screen fonts with the same "font family" point to a
- * shared instance of this structure.  The most important shared property
- * is the character existence metrics, used to determine if a screen font
- * can display a given Unicode character.
+ * The following structure represents a font family. It is assumed that all
+ * screen fonts constructed from the same "font family" share certain
+ * properties; all screen fonts with the same "font family" point to a shared
+ * instance of this structure. The most important shared property is the
+ * character existence metrics, used to determine if a screen font can display
+ * a given Unicode character.
  *
  * Under Unix, there are three attributes that uniquely identify a "font
- * family": the foundry, face name, and charset.  
+ * family": the foundry, face name, and charset.
  */
 
 #define FONTMAP_SHIFT		10
@@ -45,7 +45,7 @@ static CONST char *encodingList[] = {
 typedef struct FontFamily {
     struct FontFamily *nextPtr;	/* Next in list of all known font families. */
     int refCount;		/* How many SubFonts are referring to this
-				 * FontFamily.  When the refCount drops to
+				 * FontFamily. When the refCount drops to
 				 * zero, this FontFamily may be freed. */
     /*
      * Key.
@@ -59,58 +59,57 @@ typedef struct FontFamily {
      * Derived properties.
      */
 
-    int isTwoByteFont;		/* 1 if this is a double-byte font, 0 
+    int isTwoByteFont;		/* 1 if this is a double-byte font, 0
 				 * otherwise. */
     char *fontMap[FONTMAP_PAGES];
 				/* Two-level sparse table used to determine
 				 * quickly if the specified character exists.
 				 * As characters are encountered, more pages
-				 * in this table are dynamically alloced.  The
+				 * in this table are dynamically alloced. The
 				 * contents of each page is a bitmask
 				 * consisting of FONTMAP_BITSPERPAGE bits,
 				 * representing whether this font can be used
 				 * to display the given character at the
-				 * corresponding bit position.  The high bits
+				 * corresponding bit position. The high bits
 				 * of the character are used to pick which
 				 * page of the table is used. */
 } FontFamily;
 
 /*
- * The following structure encapsulates an individual screen font.  A font
+ * The following structure encapsulates an individual screen font. A font
  * object is made up of however many SubFonts are necessary to display a
  * stream of multilingual characters.
  */
 
 typedef struct SubFont {
-    char **fontMap;		/* Pointer to font map from the FontFamily, 
+    char **fontMap;		/* Pointer to font map from the FontFamily,
 				 * cached here to save a dereference. */
-    XFontStruct *fontStructPtr;	/* The specific screen font that will be
-				 * used when displaying/measuring chars
-				 * belonging to the FontFamily. */
+    XFontStruct *fontStructPtr;	/* The specific screen font that will be used
+				 * when displaying/measuring chars belonging
+				 * to the FontFamily. */
     FontFamily *familyPtr;	/* The FontFamily for this SubFont. */
 } SubFont;
 
 /*
- * The following structure represents Unix's implementation of a font
- * object.
+ * The following structure represents Unix's implementation of a font object.
  */
- 
+
 #define SUBFONT_SPACE		3
 #define BASE_CHARS		256
 
 typedef struct UnixFont {
-    TkFont font;		/* Stuff used by generic font package.  Must
-				 * be first in structure. */
+    TkFont font;		/* Stuff used by generic font package. Must be
+				 * first in structure. */
     SubFont staticSubFonts[SUBFONT_SPACE];
 				/* Builtin space for a limited number of
 				 * SubFonts. */
     int numSubFonts;		/* Length of following array. */
-    SubFont *subFontArray;	/* Array of SubFonts that have been loaded
-				 * in order to draw/measure all the characters
-				 * encountered by this font so far.  All fonts
+    SubFont *subFontArray;	/* Array of SubFonts that have been loaded in
+				 * order to draw/measure all the characters
+				 * encountered by this font so far. All fonts
 				 * start off with one SubFont initialized by
 				 * AllocFont() from the original set of font
-				 * attributes.  Usually points to
+				 * attributes. Usually points to
 				 * staticSubFonts, but may point to malloced
 				 * space if there are lots of SubFonts. */
     SubFont controlSubFont;	/* Font to use to display control-character
@@ -122,51 +121,50 @@ typedef struct UnixFont {
     TkXLFDAttributes xa;	/* Additional attributes that specify the
 				 * preferred foundry and encoding to use when
 				 * constructing additional SubFonts. */
-    int widths[BASE_CHARS];	/* Widths of first 256 chars in the base
-				 * font, for handling common case. */
-    int underlinePos;		/* Offset from baseline to origin of
-				 * underline bar (used when drawing underlined
-				 * font) (pixels). */
-    int barHeight;		/* Height of underline or overstrike bar
-				 * (used when drawing underlined or strikeout
-				 * font) (pixels). */
+    int widths[BASE_CHARS];	/* Widths of first 256 chars in the base font,
+				 * for handling common case. */
+    int underlinePos;		/* Offset from baseline to origin of underline
+				 * bar (used when drawing underlined font)
+				 * (pixels). */
+    int barHeight;		/* Height of underline or overstrike bar (used
+				 * when drawing underlined or strikeout font)
+				 * (pixels). */
 } UnixFont;
 
 /*
  * The following structure and definition is used to keep track of the
- * alternative names for various encodings.  Asking for an encoding that
+ * alternative names for various encodings. Asking for an encoding that
  * matches one of the alias patterns will result in actually getting the
  * encoding by its real name.
  */
- 
+
 typedef struct EncodingAlias {
     char *realName;		/* The real name of the encoding to load if
 				 * the provided name matched the pattern. */
-    char *aliasPattern;		/* Pattern for encoding name, of the form
-				 * that is acceptable to Tcl_StringMatch. */
+    char *aliasPattern;		/* Pattern for encoding name, of the form that
+				 * is acceptable to Tcl_StringMatch. */
 } EncodingAlias;
 
 /*
  * Just some utility structures used for passing around values in helper
- * procedures.
+ * functions.
  */
- 
+
 typedef struct FontAttributes {
     TkFontAttributes fa;
     TkXLFDAttributes xa;
 } FontAttributes;
 
-
 typedef struct ThreadSpecificData {
-    FontFamily *fontFamilyList; /* The list of font families that are 
-				 * currently loaded.  As screen fonts
-				 * are loaded, this list grows to hold 
-				 * information about what characters
-				 * exist in each font family. */
-    FontFamily controlFamily;   /* FontFamily used to handle control 
-				 * character expansions.  The encoding
-				 * of this FontFamily converts UTF-8 to 
-				 * backslashed escape sequences. */
+    FontFamily *fontFamilyList; /* The list of font families that are
+				 * currently loaded. As screen fonts are
+				 * loaded, this list grows to hold information
+				 * about what characters exist in each font
+				 * family. */
+    FontFamily controlFamily;   /* FontFamily used to handle control character
+				 * expansions. The encoding of this FontFamily
+				 * converts UTF-8 to backslashed escape
+				 * sequences. */
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
 
@@ -174,7 +172,7 @@ static Tcl_ThreadDataKey dataKey;
  * The set of builtin encoding alises to convert the XLFD names for the
  * encodings into the names expected by the Tcl encoding package.
  */
- 
+
 static EncodingAlias encodingAliases[] = {
     {"gb2312-raw",	"gb2312*"},
     {"big5",		"big5*"},
@@ -195,81 +193,74 @@ static EncodingAlias encodingAliases[] = {
 };
 
 /*
- * Procedures used only in this file.
+ * Functions used only in this file.
  */
 
-static void		FontPkgCleanup _ANSI_ARGS_((ClientData clientData));
-static FontFamily *	AllocFontFamily _ANSI_ARGS_((Display *display,
-			    XFontStruct *fontStructPtr, int base));
-static SubFont *	CanUseFallback _ANSI_ARGS_((UnixFont *fontPtr,
+static void		FontPkgCleanup(ClientData clientData);
+static FontFamily *	AllocFontFamily(Display *display,
+			    XFontStruct *fontStructPtr, int base);
+static SubFont *	CanUseFallback(UnixFont *fontPtr,
 			    CONST char *fallbackName, int ch,
-			    SubFont **fixSubFontPtrPtr));
-static SubFont *	CanUseFallbackWithAliases _ANSI_ARGS_((
-			    UnixFont *fontPtr, char *fallbackName,
-			    int ch, Tcl_DString *nameTriedPtr,
-			    SubFont **fixSubFontPtrPtr));
-static int		ControlUtfProc _ANSI_ARGS_((ClientData clientData,
+			    SubFont **fixSubFontPtrPtr);
+static SubFont *	CanUseFallbackWithAliases(UnixFont *fontPtr,
+			    char *fallbackName, int ch,
+			    Tcl_DString *nameTriedPtr,
+			    SubFont **fixSubFontPtrPtr);
+static int		ControlUtfProc(ClientData clientData,
 			    CONST char *src, int srcLen, int flags,
 			    Tcl_EncodingState *statePtr, char *dst,
 			    int dstLen, int *srcReadPtr, int *dstWrotePtr,
-			    int *dstCharsPtr));
-static XFontStruct *	CreateClosestFont _ANSI_ARGS_((Tk_Window tkwin,
+			    int *dstCharsPtr);
+static XFontStruct *	CreateClosestFont(Tk_Window tkwin,
 			    CONST TkFontAttributes *faPtr,
-			    CONST TkXLFDAttributes *xaPtr));
-static SubFont *	FindSubFontForChar _ANSI_ARGS_((UnixFont *fontPtr,
-			    int ch, SubFont **fixSubFontPtrPtr));
-static void		FontMapInsert _ANSI_ARGS_((SubFont *subFontPtr,
-			    int ch));
-static void		FontMapLoadPage _ANSI_ARGS_((SubFont *subFontPtr,
-			    int row));
-static int		FontMapLookup _ANSI_ARGS_((SubFont *subFontPtr,
-			    int ch));
-static void		FreeFontFamily _ANSI_ARGS_((FontFamily *afPtr));
-static CONST char *	GetEncodingAlias _ANSI_ARGS_((CONST char *name));
-static int		GetFontAttributes _ANSI_ARGS_((Display *display,
-			    XFontStruct *fontStructPtr, FontAttributes *faPtr));
-static XFontStruct *	GetScreenFont _ANSI_ARGS_((Display *display,
+			    CONST TkXLFDAttributes *xaPtr);
+static SubFont *	FindSubFontForChar(UnixFont *fontPtr,
+			    int ch, SubFont **fixSubFontPtrPtr);
+static void		FontMapInsert(SubFont *subFontPtr, int ch);
+static void		FontMapLoadPage(SubFont *subFontPtr, int row);
+static int		FontMapLookup(SubFont *subFontPtr, int ch);
+static void		FreeFontFamily(FontFamily *afPtr);
+static CONST char *	GetEncodingAlias(CONST char *name);
+static int		GetFontAttributes(Display *display,
+			    XFontStruct *fontStructPtr, FontAttributes *faPtr);
+static XFontStruct *	GetScreenFont(Display *display,
 			    FontAttributes *wantPtr, char **nameList,
-			    int bestIdx[], unsigned int bestScore[]));
-static XFontStruct *	GetSystemFont _ANSI_ARGS_((Display *display));
-static int		IdentifySymbolEncodings _ANSI_ARGS_((
-			    FontAttributes *faPtr));
-static void		InitFont _ANSI_ARGS_((Tk_Window tkwin,
-			    XFontStruct *fontStructPtr, UnixFont *fontPtr));
-static void		InitSubFont _ANSI_ARGS_((Display *display,
+			    int bestIdx[], unsigned int bestScore[]);
+static XFontStruct *	GetSystemFont(Display *display);
+static int		IdentifySymbolEncodings(FontAttributes *faPtr);
+static void		InitFont(Tk_Window tkwin,
+			    XFontStruct *fontStructPtr, UnixFont *fontPtr);
+static void		InitSubFont(Display *display,
 			    XFontStruct *fontStructPtr, int base,
-			    SubFont *subFontPtr));
-static char **		ListFonts _ANSI_ARGS_((Display *display,
-			    CONST char *faceName, int *numNamesPtr));
-static char **		ListFontOrAlias _ANSI_ARGS_((Display *display,
-			    CONST char *faceName, int *numNamesPtr));
-static unsigned int	RankAttributes _ANSI_ARGS_((FontAttributes *wantPtr,
-			    FontAttributes *gotPtr));
-static void		ReleaseFont _ANSI_ARGS_((UnixFont *fontPtr));
-static void		ReleaseSubFont _ANSI_ARGS_((Display *display, 
-			    SubFont *subFontPtr));
-static int		SeenName _ANSI_ARGS_((CONST char *name,
-			    Tcl_DString *dsPtr));
-static int		Ucs2beToUtfProc _ANSI_ARGS_((ClientData clientData,
+			    SubFont *subFontPtr);
+static char **		ListFonts(Display *display, CONST char *faceName,
+			    int *numNamesPtr);
+static char **		ListFontOrAlias(Display *display,
+			    CONST char *faceName, int *numNamesPtr);
+static unsigned int	RankAttributes(FontAttributes *wantPtr,
+			    FontAttributes *gotPtr);
+static void		ReleaseFont(UnixFont *fontPtr);
+static void		ReleaseSubFont(Display *display, SubFont *subFontPtr);
+static int		SeenName(CONST char *name, Tcl_DString *dsPtr);
+static int		Ucs2beToUtfProc(ClientData clientData,
 			    CONST char *src, int srcLen, int flags,
 			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 			    int *srcReadPtr, int *dstWrotePtr,
-			    int *dstCharsPtr));
-static int		UtfToUcs2beProc _ANSI_ARGS_((ClientData clientData,
+			    int *dstCharsPtr);
+static int		UtfToUcs2beProc(ClientData clientData,
 			    CONST char *src, int srcLen, int flags,
 			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 			    int *srcReadPtr, int *dstWrotePtr,
-			    int *dstCharsPtr));
-
+			    int *dstCharsPtr);
 
 /*
  *-------------------------------------------------------------------------
  *
  * FontPkgCleanup --
  *
- *	This procedure is called when an application is created.  It
- *	initializes all the structures that are used by the
- *	platform-dependent code on a per application basis.
+ *	This function is called when an application is created. It initializes
+ *	all the structures that are used by the platform-dependent code on a
+ *	per application basis.
  *
  * Results:
  *	None.
@@ -281,11 +272,12 @@ static int		UtfToUcs2beProc _ANSI_ARGS_((ClientData clientData,
  */
 
 static void
-FontPkgCleanup(ClientData clientData)
+FontPkgCleanup(
+    ClientData clientData)
 {
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
-    
+
     if (tsdPtr->controlFamily.encoding != NULL) {
 	FontFamily *familyPtr = &tsdPtr->controlFamily;
 	int i;
@@ -305,9 +297,9 @@ FontPkgCleanup(ClientData clientData)
  *
  * TkpFontPkgInit --
  *
- *	This procedure is called when an application is created.  It
- *	initializes all the structures that are used by the
- *	platform-dependent code on a per application basis.
+ *	This function is called when an application is created. It initializes
+ *	all the structures that are used by the platform-dependent code on a
+ *	per application basis.
  *
  * Results:
  *	None.
@@ -319,23 +311,23 @@ FontPkgCleanup(ClientData clientData)
  */
 
 void
-TkpFontPkgInit(mainPtr)
-    TkMainInfo *mainPtr;	/* The application being created. */
+TkpFontPkgInit(
+    TkMainInfo *mainPtr)	/* The application being created. */
 {
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
     Tcl_EncodingType type;
     SubFont dummy;
     int i;
-    
+
     if (tsdPtr->controlFamily.encoding == NULL) {
-	type.encodingName	= "X11ControlChars";
-	type.toUtfProc		= ControlUtfProc;
-	type.fromUtfProc	= ControlUtfProc;
-	type.freeProc		= NULL;
-	type.clientData		= NULL;
-	type.nullSize		= 0;
-	
+	type.encodingName = "X11ControlChars";
+	type.toUtfProc = ControlUtfProc;
+	type.fromUtfProc = ControlUtfProc;
+	type.freeProc = NULL;
+	type.clientData = NULL;
+	type.nullSize = 0;
+
 	tsdPtr->controlFamily.refCount = 2;
 	tsdPtr->controlFamily.encoding = Tcl_CreateEncoding(&type);
 	tsdPtr->controlFamily.isTwoByteFont = 0;
@@ -348,16 +340,16 @@ TkpFontPkgInit(mainPtr)
 	}
 
 	/*
-	 * UCS-2BE is unicode in big-endian format.
-	 * It is used in iso10646 fonts.
+	 * UCS-2BE is unicode in big-endian format. It is used in iso10646
+	 * fonts.
 	 */
 
-	type.encodingName	= "ucs-2be";
-	type.toUtfProc		= Ucs2beToUtfProc;
-	type.fromUtfProc	= UtfToUcs2beProc;
-	type.freeProc		= NULL;
-	type.clientData		= NULL;
-	type.nullSize		= 2;
+	type.encodingName = "ucs-2be";
+	type.toUtfProc = Ucs2beToUtfProc;
+	type.fromUtfProc = UtfToUcs2beProc;
+	type.freeProc = NULL;
+	type.clientData = NULL;
+	type.nullSize = 2;
 	Tcl_CreateEncoding(&type);
 	Tcl_CreateThreadExitHandler(FontPkgCleanup, NULL);
     }
@@ -368,8 +360,7 @@ TkpFontPkgInit(mainPtr)
  *
  * ControlUtfProc --
  *
- *	Convert from UTF-8 into the ASCII expansion of a control
- *	character.
+ *	Convert from UTF-8 into the ASCII expansion of a control character.
  *
  * Results:
  *	Returns TCL_OK if conversion was successful.
@@ -380,31 +371,30 @@ TkpFontPkgInit(mainPtr)
  *-------------------------------------------------------------------------
  */
 
-static int 
-ControlUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
-	srcReadPtr, dstWrotePtr, dstCharsPtr)
-    ClientData clientData;	/* Not used. */
-    CONST char *src;		/* Source string in UTF-8. */
-    int srcLen;			/* Source string length in bytes. */
-    int flags;			/* Conversion control flags. */
-    Tcl_EncodingState *statePtr;/* Place for conversion routine to store
-				 * state information used during a piecewise
-				 * conversion.  Contents of statePtr are
+static int
+ControlUtfProc(
+    ClientData clientData,	/* Not used. */
+    CONST char *src,		/* Source string in UTF-8. */
+    int srcLen,			/* Source string length in bytes. */
+    int flags,			/* Conversion control flags. */
+    Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
+				 * information used during a piecewise
+				 * conversion. Contents of statePtr are
 				 * initialized and/or reset by conversion
 				 * routine under control of flags argument. */
-    char *dst;			/* Output buffer in which converted string
-				 * is stored. */
-    int dstLen;			/* The maximum length of output buffer in
+    char *dst,			/* Output buffer in which converted string is
+				 * stored. */
+    int dstLen,			/* The maximum length of output buffer in
 				 * bytes. */
-    int *srcReadPtr;		/* Filled with the number of bytes from the
-				 * source string that were converted.  This
-				 * may be less than the original source length
-				 * if there was a problem converting some
-				 * source characters. */
-    int *dstWrotePtr;		/* Filled with the number of bytes that were
+    int *srcReadPtr,		/* Filled with the number of bytes from the
+				 * source string that were converted. This may
+				 * be less than the original source length if
+				 * there was a problem converting some source
+				 * characters. */
+    int *dstWrotePtr,		/* Filled with the number of bytes that were
 				 * stored in the output buffer as a result of
 				 * the conversion. */
-    int *dstCharsPtr;		/* Filled with the number of characters that
+    int *dstCharsPtr)		/* Filled with the number of characters that
 				 * correspond to the bytes stored in the
 				 * output buffer. */
 {
@@ -472,38 +462,37 @@ ControlUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
  *-------------------------------------------------------------------------
  */
 
-static int 
-Ucs2beToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
-	srcReadPtr, dstWrotePtr, dstCharsPtr)
-    ClientData clientData;	/* Not used. */
-    CONST char *src;		/* Source string in Unicode. */
-    int srcLen;			/* Source string length in bytes. */
-    int flags;			/* Conversion control flags. */
-    Tcl_EncodingState *statePtr;/* Place for conversion routine to store
-				 * state information used during a piecewise
-				 * conversion.  Contents of statePtr are
+static int
+Ucs2beToUtfProc(
+    ClientData clientData,	/* Not used. */
+    CONST char *src,		/* Source string in Unicode. */
+    int srcLen			/* Source string length in bytes. */
+    int flags			/* Conversion control flags. */
+    Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
+				 * information used during a piecewise
+				 * conversion. Contents of statePtr are
 				 * initialized and/or reset by conversion
 				 * routine under control of flags argument. */
-    char *dst;			/* Output buffer in which converted string
-				 * is stored. */
-    int dstLen;			/* The maximum length of output buffer in
+    char *dst,			/* Output buffer in which converted string is
+				 * stored. */
+    int dstLen,			/* The maximum length of output buffer in
 				 * bytes. */
-    int *srcReadPtr;		/* Filled with the number of bytes from the
-				 * source string that were converted.  This
-				 * may be less than the original source length
-				 * if there was a problem converting some
-				 * source characters. */
-    int *dstWrotePtr;		/* Filled with the number of bytes that were
+    int *srcReadPtr,		/* Filled with the number of bytes from the
+				 * source string that were converted. This may
+				 * be less than the original source length if
+				 * there was a problem converting some source
+				 * characters. */
+    int *dstWrotePtr,		/* Filled with the number of bytes that were
 				 * stored in the output buffer as a result of
 				 * the conversion. */
-    int *dstCharsPtr;		/* Filled with the number of characters that
+    int *dstCharsPtr)		/* Filled with the number of characters that
 				 * correspond to the bytes stored in the
 				 * output buffer. */
 {
     CONST Tcl_UniChar *wSrc, *wSrcStart, *wSrcEnd;
     char *dstEnd, *dstStart;
     int result, numChars;
-    
+
     result = TCL_OK;
     if ((srcLen % sizeof(Tcl_UniChar)) != 0) {
 	result = TCL_CONVERT_MULTIBYTE;
@@ -524,11 +513,13 @@ Ucs2beToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
 	    result = TCL_CONVERT_NOSPACE;
 	    break;
 	}
-	/* 
-	 * On a little-endian machine (Intel) the UCS-2BE is in the
-	 * wrong byte-order in comparison to "unicode", which is
-	 * in native host order.
+
+	/*
+	 * On a little-endian machine (Intel) the UCS-2BE is in the wrong
+	 * byte-order in comparison to "unicode", which is in native host
+	 * order.
 	 */
+
 	dst += Tcl_UniCharToUtf(htons(*wSrc), dst);
 	wSrc++;
     }
@@ -555,38 +546,38 @@ Ucs2beToUtfProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
  *-------------------------------------------------------------------------
  */
 
-static int 
-UtfToUcs2beProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
-	srcReadPtr, dstWrotePtr, dstCharsPtr)
-    ClientData clientData;	/* TableEncodingData that specifies encoding. */
-    CONST char *src;		/* Source string in UTF-8. */
-    int srcLen;			/* Source string length in bytes. */
-    int flags;			/* Conversion control flags. */
-    Tcl_EncodingState *statePtr;/* Place for conversion routine to store
-				 * state information used during a piecewise
-				 * conversion.  Contents of statePtr are
+static int
+UtfToUcs2beProc(
+    ClientData clientData,	/* TableEncodingData that specifies
+				 * encoding. */
+    CONST char *src,		/* Source string in UTF-8. */
+    int srcLen,			/* Source string length in bytes. */
+    int flags,			/* Conversion control flags. */
+    Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
+				 * information used during a piecewise
+				 * conversion. Contents of statePtr are
 				 * initialized and/or reset by conversion
 				 * routine under control of flags argument. */
-    char *dst;			/* Output buffer in which converted string
-				 * is stored. */
-    int dstLen;			/* The maximum length of output buffer in
+    char *dst,			/* Output buffer in which converted string is
+				 * stored. */
+    int dstLen,			/* The maximum length of output buffer in
 				 * bytes. */
-    int *srcReadPtr;		/* Filled with the number of bytes from the
-				 * source string that were converted.  This
-				 * may be less than the original source length
-				 * if there was a problem converting some
-				 * source characters. */
-    int *dstWrotePtr;		/* Filled with the number of bytes that were
+    int *srcReadPtr,		/* Filled with the number of bytes from the
+				 * source string that were converted. This may
+				 * be less than the original source length if
+				 * there was a problem converting some source
+				 * characters. */
+    int *dstWrotePtr,		/* Filled with the number of bytes that were
 				 * stored in the output buffer as a result of
 				 * the conversion. */
-    int *dstCharsPtr;		/* Filled with the number of characters that
+    int *dstCharsPtr)		/* Filled with the number of characters that
 				 * correspond to the bytes stored in the
 				 * output buffer. */
 {
     CONST char *srcStart, *srcEnd, *srcClose;
     Tcl_UniChar *wDst, *wDstStart, *wDstEnd;
     int result, numChars;
-    
+
     srcStart = src;
     srcEnd = src + srcLen;
     srcClose = srcEnd;
@@ -614,9 +605,11 @@ UtfToUcs2beProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
 	    break;
         }
 	src += Tcl_UtfToUniChar(src, wDst);
+
 	/*
 	 * Byte swap for little-endian machines.
 	 */
+
 	*wDst = htons(*wDst);
 	wDst++;
     }
@@ -634,28 +627,28 @@ UtfToUcs2beProc(clientData, src, srcLen, flags, statePtr, dst, dstLen,
  *	Map a platform-specific native font name to a TkFont.
  *
  * Results:
- * 	The return value is a pointer to a TkFont that represents the
- *	native font.  If a native font by the given name could not be
- *	found, the return value is NULL.  
+ *	The return value is a pointer to a TkFont that represents the native
+ *	font. If a native font by the given name could not be found, the
+ *	return value is NULL.
  *
- *	Every call to this procedure returns a new TkFont structure,
- *	even if the name has already been seen before.  The caller should
- *	call TkpDeleteFont() when the font is no longer needed.
+ *	Every call to this function returns a new TkFont structure, even if
+ *	the name has already been seen before. The caller should call
+ *	TkpDeleteFont() when the font is no longer needed.
  *
- *	The caller is responsible for initializing the memory associated
- *	with the generic TkFont when this function returns and releasing
- *	the contents of the generic TkFont before calling TkpDeleteFont().
+ *	The caller is responsible for initializing the memory associated with
+ *	the generic TkFont when this function returns and releasing the
+ *	contents of the generic TkFont before calling TkpDeleteFont().
  *
  * Side effects:
  *	Memory allocated.
  *
  *---------------------------------------------------------------------------
  */
- 
+
 TkFont *
-TkpGetNativeFont(tkwin, name)
-    Tk_Window tkwin;		/* For display where font will be used. */
-    CONST char *name;		/* Platform-specific font name. */
+TkpGetNativeFont(
+    Tk_Window tkwin,		/* For display where font will be used. */
+    CONST char *name)		/* Platform-specific font name. */
 {
     UnixFont *fontPtr;
     XFontStruct *fontStructPtr;
@@ -667,8 +660,8 @@ TkpGetNativeFont(tkwin, name)
      * The behavior of X when given a name that isn't an XLFD is unspecified.
      * For example, Exceed 6 returns a valid font for any random string. This
      * is awkward since system names have higher priority than the other Tk
-     * font syntaxes.  So, we need to perform a quick sanity check on the
-     * name and fail if it looks suspicious.  We fail if the name:
+     * font syntaxes. So, we need to perform a quick sanity check on the name
+     * and fail if it looks suspicious. We fail if the name:
      *     - contains a space immediately before a dash
      *	   - contains a space, but no '*' characters and fewer than 14 dashes
      */
@@ -693,18 +686,18 @@ TkpGetNativeFont(tkwin, name)
     fontStructPtr = XLoadQueryFont(Tk_Display(tkwin), name);
     if (fontStructPtr == NULL) {
 	/*
-	 * Handle all names that look like XLFDs here.  Otherwise, when
-	 * TkpGetFontFromAttributes is called from generic code, any
-	 * foundry or encoding information specified in the XLFD will have
-	 * been parsed out and lost.  But make sure we don't have an
-	 * "-option value" string since TkFontParseXLFD would return a
-	 * false success when attempting to parse it.
+	 * Handle all names that look like XLFDs here. Otherwise, when
+	 * TkpGetFontFromAttributes is called from generic code, any foundry
+	 * or encoding information specified in the XLFD will have been parsed
+	 * out and lost. But make sure we don't have an "-option value" string
+	 * since TkFontParseXLFD would return a false success when attempting
+	 * to parse it.
 	 */
 
 	if (name[0] == '-') {
 	    if (name[1] != '*') {
 		char *dash;
-		
+
 		dash = strchr(name + 1, '-');
 		if ((dash == NULL) || (isspace(UCHAR(dash[-1])))) {
 		    return NULL;
@@ -727,41 +720,42 @@ TkpGetNativeFont(tkwin, name)
 /*
  *---------------------------------------------------------------------------
  *
- * TkpGetFontFromAttributes -- 
+ * TkpGetFontFromAttributes --
  *
- *	Given a desired set of attributes for a font, find a font with
- *	the closest matching attributes.
+ *	Given a desired set of attributes for a font, find a font with the
+ *	closest matching attributes.
  *
  * Results:
- * 	The return value is a pointer to a TkFont that represents the
- *	font with the desired attributes.  If a font with the desired
- *	attributes could not be constructed, some other font will be
- *	substituted automatically.
+ *	The return value is a pointer to a TkFont that represents the font
+ *	with the desired attributes. If a font with the desired attributes
+ *	could not be constructed, some other font will be substituted
+ *	automatically.
  *
- *	Every call to this procedure returns a new TkFont structure,
- *	even if the specified attributes have already been seen before.
- *	The caller should call TkpDeleteFont() to free the platform-
- *	specific data when the font is no longer needed.  
+ *	Every call to this function returns a new TkFont structure, even if
+ *	the specified attributes have already been seen before. The caller
+ *	should call TkpDeleteFont() to free the platform- specific data when
+ *	the font is no longer needed.
  *
- *	The caller is responsible for initializing the memory associated
- *	with the generic TkFont when this function returns and releasing
- *	the contents of the generic TkFont before calling TkpDeleteFont().
+ *	The caller is responsible for initializing the memory associated with
+ *	the generic TkFont when this function returns and releasing the
+ *	contents of the generic TkFont before calling TkpDeleteFont().
  *
  * Side effects:
  *	Memory allocated.
  *
  *---------------------------------------------------------------------------
  */
+
 TkFont *
-TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
-    TkFont *tkFontPtr;		/* If non-NULL, store the information in
-				 * this existing TkFont structure, rather than
+TkpGetFontFromAttributes(
+    TkFont *tkFontPtr,		/* If non-NULL, store the information in this
+				 * existing TkFont structure, rather than
 				 * allocating a new structure to hold the
 				 * font; the existing contents of the font
-				 * will be released.  If NULL, a new TkFont
+				 * will be released. If NULL, a new TkFont
 				 * structure is allocated. */
-    Tk_Window tkwin;		/* For display where font will be used. */
-    CONST TkFontAttributes *faPtr;
+    Tk_Window tkwin,		/* For display where font will be used. */
+    CONST TkFontAttributes *faPtr)
 				/* Set of attributes to match. */
 {
     UnixFont *fontPtr;
@@ -791,9 +785,9 @@ TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
  * TkpDeleteFont --
  *
  *	Called to release a font allocated by TkpGetNativeFont() or
- *	TkpGetFontFromAttributes().  The caller should have already
- *	released the fields of the TkFont that are used exclusively by
- *	the generic TkFont code.
+ *	TkpGetFontFromAttributes(). The caller should have already released
+ *	the fields of the TkFont that are used exclusively by the generic
+ *	TkFont code.
  *
  * Results:
  *	None.
@@ -805,8 +799,8 @@ TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
  */
 
 void
-TkpDeleteFont(tkFontPtr)
-    TkFont *tkFontPtr;		/* Token of font to be deleted. */
+TkpDeleteFont(
+    TkFont *tkFontPtr)		/* Token of font to be deleted. */
 {
     UnixFont *fontPtr;
 
@@ -819,8 +813,8 @@ TkpDeleteFont(tkFontPtr)
  *
  * TkpGetFontFamilies --
  *
- *	Return information about the font families that are available
- *	on the display of the given window.
+ *	Return information about the font families that are available on the
+ *	display of the given window.
  *
  * Results:
  *	Modifies interp's result object to hold a list of all the available
@@ -833,9 +827,9 @@ TkpDeleteFont(tkFontPtr)
  */
 
 void
-TkpGetFontFamilies(interp, tkwin)
-    Tcl_Interp *interp;		/* Interp to hold result. */
-    Tk_Window tkwin;		/* For display to query. */
+TkpGetFontFamilies(
+    Tcl_Interp *interp,		/* Interp to hold result. */
+    Tk_Window tkwin)		/* For display to query. */
 {
     int i, new, numNames;
     char *family;
@@ -845,7 +839,7 @@ TkpGetFontFamilies(interp, tkwin)
     char **nameList;
     Tcl_Obj *resultPtr, *strPtr;
 
-    resultPtr = Tcl_GetObjResult(interp);    
+    resultPtr = Tcl_GetObjResult(interp);
 
     Tcl_InitHashTable(&familyTable, TCL_STRING_KEYS);
     nameList = ListFonts(Tk_Display(tkwin), "*", &numNames);
@@ -858,7 +852,7 @@ TkpGetFontFamilies(interp, tkwin)
 
     hPtr = Tcl_FirstHashEntry(&familyTable, &search);
     while (hPtr != NULL) {
-	strPtr = Tcl_NewStringObj(Tcl_GetHashKey(&familyTable, hPtr), -1); 
+	strPtr = Tcl_NewStringObj(Tcl_GetHashKey(&familyTable, hPtr), -1);
 	Tcl_ListObjAppendElement(NULL, resultPtr, strPtr);
 	hPtr = Tcl_NextHashEntry(&search);
     }
@@ -871,12 +865,12 @@ TkpGetFontFamilies(interp, tkwin)
  *
  * TkpGetSubFonts --
  *
- *	A function used by the testing package for querying the actual 
- *	screen fonts that make up a font object.
+ *	A function used by the testing package for querying the actual screen
+ *	fonts that make up a font object.
  *
  * Results:
- *	Modifies interp's result object to hold a list containing the 
- *	names of the screen fonts that make up the given font object.
+ *	Modifies interp's result object to hold a list containing the names of
+ *	the screen fonts that make up the given font object.
  *
  * Side effects:
  *	None.
@@ -885,9 +879,9 @@ TkpGetFontFamilies(interp, tkwin)
  */
 
 void
-TkpGetSubFonts(interp, tkfont)
-    Tcl_Interp *interp;
-    Tk_Font tkfont;
+TkpGetSubFonts(
+    Tcl_Interp *interp,
+    Tk_Font tkfont)
 {
     int i;
     Tcl_Obj *objv[3];
@@ -895,13 +889,14 @@ TkpGetSubFonts(interp, tkfont)
     UnixFont *fontPtr;
     FontFamily *familyPtr;
 
-    resultPtr = Tcl_GetObjResult(interp);    
+    resultPtr = Tcl_GetObjResult(interp);
     fontPtr = (UnixFont *) tkfont;
     for (i = 0; i < fontPtr->numSubFonts; i++) {
 	familyPtr = fontPtr->subFontArray[i].familyPtr;
 	objv[0] = Tcl_NewStringObj(familyPtr->faceName, -1);
 	objv[1] = Tcl_NewStringObj(familyPtr->foundry, -1);
-	objv[2] = Tcl_NewStringObj(Tcl_GetEncodingName(familyPtr->encoding), -1);
+	objv[2] = Tcl_NewStringObj(
+		Tcl_GetEncodingName(familyPtr->encoding), -1);
 	listPtr = Tcl_NewListObj(3, objv);
 	Tcl_ListObjAppendElement(NULL, resultPtr, listPtr);
     }
@@ -912,16 +907,15 @@ TkpGetSubFonts(interp, tkfont)
  *
  *  Tk_MeasureChars --
  *
- *	Determine the number of characters from the string that will fit
- *	in the given horizontal span.  The measurement is done under the
- *	assumption that Tk_DrawChars() will be used to actually display
- *	the characters.
+ *	Determine the number of characters from the string that will fit in
+ *	the given horizontal span. The measurement is done under the
+ *	assumption that Tk_DrawChars() will be used to actually display the
+ *	characters.
  *
  * Results:
- *	The return value is the number of bytes from source that
- *	fit into the span that extends from 0 to maxLength.  *lengthPtr is
- *	filled with the x-coordinate of the right edge of the last
- *	character that did fit.
+ *	The return value is the number of bytes from source that fit into the
+ *	span that extends from 0 to maxLength. *lengthPtr is filled with the
+ *	x-coordinate of the right edge of the last character that did fit.
  *
  * Side effects:
  *	None.
@@ -930,26 +924,26 @@ TkpGetSubFonts(interp, tkfont)
  */
 
 int
-Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
-    Tk_Font tkfont;		/* Font in which characters will be drawn. */
-    CONST char *source;		/* UTF-8 string to be displayed.  Need not be
+Tk_MeasureChars(
+    Tk_Font tkfont,		/* Font in which characters will be drawn. */
+    CONST char *source,		/* UTF-8 string to be displayed. Need not be
 				 * '\0' terminated. */
-    int numBytes;		/* Maximum number of bytes to consider
-				 * from source string. */
-    int maxLength;		/* If >= 0, maxLength specifies the longest
+    int numBytes,		/* Maximum number of bytes to consider from
+				 * source string. */
+    int maxLength,		/* If >= 0, maxLength specifies the longest
 				 * permissible line length in pixels; don't
 				 * consider any character that would cross
-				 * this x-position.  If < 0, then line length
+				 * this x-position. If < 0, then line length
 				 * is unbounded and the flags argument is
 				 * ignored. */
-    int flags;			/* Various flag bits OR-ed together:
+    int flags,			/* Various flag bits OR-ed together:
 				 * TK_PARTIAL_OK means include the last char
 				 * which only partially fit on this line.
 				 * TK_WHOLE_WORDS means stop on a word
-				 * boundary, if possible.
-				 * TK_AT_LEAST_ONE means return at least one
-				 * character even if no characters fit. */
-    int *lengthPtr;		/* Filled with x-location just after the
+				 * boundary, if possible. TK_AT_LEAST_ONE
+				 * means return at least one character even if
+				 * no characters fit. */
+    int *lengthPtr)		/* Filled with x-location just after the
 				 * terminating character. */
 {
     UnixFont *fontPtr;
@@ -958,9 +952,9 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 
     /*
      * Unix does not use kerning or fractional character widths when
-     * displaying text on the screen.  So that means we can safely measure
-     * individual characters or spans of characters and add up the widths
-     * w/o any "off-by-one-pixel" errors.
+     * displaying text on the screen. So that means we can safely measure
+     * individual characters or spans of characters and add up the widths w/o
+     * any "off-by-one-pixel" errors.
      */
 
     fontPtr = (UnixFont *) tkfont;
@@ -979,7 +973,7 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 
 	/*
 	 * A three step process:
-	 * 1. Find a contiguous range of characters that can all be 
+	 * 1. Find a contiguous range of characters that can all be
 	 *    represented by a single screen font.
 	 * 2. Convert those chars to the encoding of that font.
 	 * 3. Measure converted chars.
@@ -1031,14 +1025,14 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 	char buf[16];
 
 	/*
-	 * How many chars will fit in the space allotted? 
-	 * This first version may be inefficient because it measures
-	 * every character individually.
+	 * How many chars will fit in the space allotted? This first version
+	 * may be inefficient because it measures every character
+	 * individually.
 	 */
 
 	next = source + Tcl_UtfToUniChar(source, &ch);
 	newX = curX = termX = 0;
-	
+
 	term = source;
 	end = source + numBytes;
 
@@ -1085,14 +1079,14 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 
 	/*
 	 * P points to the first character that doesn't fit in the desired
-	 * span.  Use the flags to figure out what to return.
+	 * span. Use the flags to figure out what to return.
 	 */
 
 	if ((flags & TK_PARTIAL_OK) && (p < end) && (curX < maxLength)) {
 	    /*
-	     * Include the first character that didn't quite fit in the desired
-	     * span.  The width returned will include the width of that extra
-	     * character.
+	     * Include the first character that didn't quite fit in the
+	     * desired span. The width returned will include the width of that
+	     * extra character.
 	     */
 
 	    curX = newX;
@@ -1111,7 +1105,7 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 	}
 
 	curX = termX;
-	curByte = term - source;	
+	curByte = term - source;
     }
 
     *lengthPtr = curX;
@@ -1123,9 +1117,8 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
  *
  * Tk_DrawChars --
  *
- *	Draw a string of characters on the screen.  Tk_DrawChars()
- *	expands control characters that occur in the string to 
- *	\xNN sequences.  
+ *	Draw a string of characters on the screen. Tk_DrawChars() expands
+ *	control characters that occur in the string to \xNN sequences.
  *
  * Results:
  *	None.
@@ -1137,21 +1130,21 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
  */
 
 void
-Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
-    Display *display;		/* Display on which to draw. */
-    Drawable drawable;		/* Window or pixmap in which to draw. */
-    GC gc;			/* Graphics context for drawing characters. */
-    Tk_Font tkfont;		/* Font in which characters will be drawn;
+Tk_DrawChars(
+    Display *display,		/* Display on which to draw. */
+    Drawable drawable,		/* Window or pixmap in which to draw. */
+    GC gc,			/* Graphics context for drawing characters. */
+    Tk_Font tkfont,		/* Font in which characters will be drawn;
 				 * must be the same as font used in GC. */
-    CONST char *source;		/* UTF-8 string to be displayed.  Need not be
-				 * '\0' terminated.  All Tk meta-characters
+    CONST char *source,		/* UTF-8 string to be displayed. Need not be
+				 * '\0' terminated. All Tk meta-characters
 				 * (tabs, control characters, and newlines)
 				 * should be stripped out of the string that
-				 * is passed to this function.  If they are
-				 * not stripped out, they will be displayed as
+				 * is passed to this function. If they are not
+				 * stripped out, they will be displayed as
 				 * regular printing characters. */
-    int numBytes;		/* Number of bytes in string. */
-    int x, y;			/* Coordinates at which to place origin of
+    int numBytes,		/* Number of bytes in string. */
+    int x, int y)		/* Coordinates at which to place origin of
 				 * string when drawing. */
 {
     UnixFont *fontPtr;
@@ -1176,6 +1169,7 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
     /*
      * Get the window width so we can abort drawing outside of the window
      */
+
     if (XGetGeometry(display, drawable, &root, &rx, &ry, &width, &height,
 	    &border_width, &depth) == False) {
 	window_width = INT_MAX;
@@ -1187,6 +1181,7 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
      * This is used by default until we find a solution that doesn't
      * round-trip to the X server (need to get Tk cached window width).
      */
+
     window_width = 32768;
 #endif
 
@@ -1209,7 +1204,7 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
 		Tcl_UtfToExternalDString(familyPtr->encoding, source,
 			p - source, &runString);
 		if (familyPtr->isTwoByteFont) {
-		    XDrawString16(display, drawable, gc, x, y, 
+		    XDrawString16(display, drawable, gc, x, y,
 			    (XChar2b *) Tcl_DStringValue(&runString),
 			    Tcl_DStringLength(&runString) / 2);
 		    if (do_width) {
@@ -1263,21 +1258,20 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
  *
  * CreateClosestFont --
  *
- *	Helper for TkpGetNativeFont() and TkpGetFontFromAttributes().
- *	Given a set of font attributes, construct a close XFontStruct.
- *	If requested face name is not available, automatically
- *	substitutes an alias for requested face name.  If encoding is
- *	not specified (or the requested one is not available),
- *	automatically chooses another encoding from the list of
- *	preferred encodings.  If the foundry is not specified (or
- *	is not available) automatically prefers "adobe" foundry.
- *	For all other attributes, if the requested value was not
- *	available, the appropriate "close" value will be used.
+ *	Helper for TkpGetNativeFont() and TkpGetFontFromAttributes(). Given a
+ *	set of font attributes, construct a close XFontStruct. If requested
+ *	face name is not available, automatically substitutes an alias for
+ *	requested face name. If encoding is not specified (or the requested
+ *	one is not available), automatically chooses another encoding from the
+ *	list of preferred encodings. If the foundry is not specified (or is
+ *	not available) automatically prefers "adobe" foundry. For all other
+ *	attributes, if the requested value was not available, the appropriate
+ *	"close" value will be used.
  *
  * Results:
- *	Return value is the XFontStruct that best matched the
- *	requested attributes.  The return value is never NULL; some
- *	font will always be returned.
+ *	Return value is the XFontStruct that best matched the requested
+ *	attributes. The return value is never NULL; some font will always be
+ *	returned.
  *
  * Side effects:
  *	None.
@@ -1286,11 +1280,11 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
  */
 
 static XFontStruct *
-CreateClosestFont(tkwin, faPtr, xaPtr)
-    Tk_Window tkwin;		/* For display where font will be used. */
-    CONST TkFontAttributes *faPtr;	
+CreateClosestFont(
+    Tk_Window tkwin,		/* For display where font will be used. */
+    CONST TkFontAttributes *faPtr,
 				/* Set of generic attributes to match. */
-    CONST TkXLFDAttributes *xaPtr;
+    CONST TkXLFDAttributes *xaPtr)
 				/* Set of X-specific attributes to match. */
 {
     FontAttributes want;
@@ -1332,7 +1326,7 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
 	char ***fontFallbacks;
 	int i, j;
 	char *fallback;
-	
+
 	fontFallbacks = TkFontGetFallbacks();
 	for (i = 0; fontFallbacks[i] != NULL; i++) {
 	    for (j = 0; (fallback = fontFallbacks[i][j]) != NULL; j++) {
@@ -1357,7 +1351,8 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
 	    return GetSystemFont(display);
 	}
     }
-    found:
+
+  found:
     bestIdx[0] = -1;
     bestIdx[1] = -1;
     bestScore[0] = (unsigned int) -1;
@@ -1382,9 +1377,10 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
 	}
     }
 
-    fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx, bestScore);
+    fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx,
+	    bestScore);
     XFreeFontNames(nameList);
-    
+
     if (fontStructPtr == NULL) {
 	return GetSystemFont(display);
     }
@@ -1397,12 +1393,12 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
  * InitFont --
  *
  *	Helper for TkpGetNativeFont() and TkpGetFontFromAttributes().
- *	Initializes the memory for a new UnixFont that 	wraps the
+ *	Initializes the memory for a new UnixFont that wraps the
  *	platform-specific data.
  *
- *	The caller is responsible for initializing the fields of the
- *	TkFont that are used exclusively by the generic TkFont code, and
- *	for releasing those fields before calling TkpDeleteFont().
+ *	The caller is responsible for initializing the fields of the TkFont
+ *	that are used exclusively by the generic TkFont code, and for
+ *	releasing those fields before calling TkpDeleteFont().
  *
  * Results:
  *	Fills the WinFont structure.
@@ -1411,16 +1407,16 @@ CreateClosestFont(tkwin, faPtr, xaPtr)
  *	Memory allocated.
  *
  *---------------------------------------------------------------------------
- */ 
+ */
 
 static void
-InitFont(tkwin, fontStructPtr, fontPtr)
-    Tk_Window tkwin;		/* For screen where font will be used. */
-    XFontStruct *fontStructPtr;	/* X information about font. */
-    UnixFont *fontPtr;		/* Filled with information constructed from
+InitFont(
+    Tk_Window tkwin,		/* For screen where font will be used. */
+    XFontStruct *fontStructPtr,	/* X information about font. */
+    UnixFont *fontPtr)		/* Filled with information constructed from
 				 * the above arguments. */
 {
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
     unsigned long value;
     int minHi, maxHi, minLo, maxLo, fixed, width, limit, i, n;
@@ -1434,7 +1430,7 @@ InitFont(tkwin, fontStructPtr, fontPtr)
     /*
      * Get all font attributes and metrics.
      */
-     
+
     display = Tk_Display(tkwin);
     GetFontAttributes(display, fontStructPtr, &fa);
 
@@ -1442,7 +1438,7 @@ InitFont(tkwin, fontStructPtr, fontPtr)
     maxHi = fontStructPtr->max_byte1;
     minLo = fontStructPtr->min_char_or_byte2;
     maxLo = fontStructPtr->max_char_or_byte2;
-	
+
     fixed = 1;
     if (fontStructPtr->per_char != NULL) {
 	width = 0;
@@ -1460,41 +1456,41 @@ InitFont(tkwin, fontStructPtr, fontPtr)
 	}
     }
 
-    fontPtr->font.fid	= fontStructPtr->fid;
+    fontPtr->font.fid = fontStructPtr->fid;
 
-    faPtr		= &fontPtr->font.fa;
-    faPtr->family	= fa.fa.family;
-    faPtr->size		= TkFontGetPoints(tkwin, fa.fa.size);
-    faPtr->weight	= fa.fa.weight;
-    faPtr->slant	= fa.fa.slant;
-    faPtr->underline	= 0;
-    faPtr->overstrike	= 0;
+    faPtr = &fontPtr->font.fa;
+    faPtr->family = fa.fa.family;
+    faPtr->size = TkFontGetPoints(tkwin, fa.fa.size);
+    faPtr->weight = fa.fa.weight;
+    faPtr->slant = fa.fa.slant;
+    faPtr->underline = 0;
+    faPtr->overstrike = 0;
 
-    fmPtr		= &fontPtr->font.fm;
-    fmPtr->ascent	= fontStructPtr->ascent;
-    fmPtr->descent	= fontStructPtr->descent;
-    fmPtr->maxWidth	= fontStructPtr->max_bounds.width;
-    fmPtr->fixed	= fixed;
+    fmPtr = &fontPtr->font.fm;
+    fmPtr->ascent = fontStructPtr->ascent;
+    fmPtr->descent = fontStructPtr->descent;
+    fmPtr->maxWidth = fontStructPtr->max_bounds.width;
+    fmPtr->fixed = fixed;
 
-    fontPtr->display	= display;
-    fontPtr->pixelSize	= TkFontGetPixels(tkwin, fa.fa.size);
-    fontPtr->xa		= fa.xa;
+    fontPtr->display = display;
+    fontPtr->pixelSize = TkFontGetPixels(tkwin, fa.fa.size);
+    fontPtr->xa = fa.xa;
 
-    fontPtr->numSubFonts	= 1;
-    fontPtr->subFontArray	= fontPtr->staticSubFonts;
+    fontPtr->numSubFonts = 1;
+    fontPtr->subFontArray = fontPtr->staticSubFonts;
     InitSubFont(display, fontStructPtr, 1, &fontPtr->subFontArray[0]);
 
-    fontPtr->controlSubFont	= fontPtr->subFontArray[0];
-    subFontPtr			= FindSubFontForChar(fontPtr, '0', NULL);
-    controlPtr			= &fontPtr->controlSubFont;
-    controlPtr->fontStructPtr	= subFontPtr->fontStructPtr;
-    controlPtr->familyPtr	= &tsdPtr->controlFamily;
-    controlPtr->fontMap		= tsdPtr->controlFamily.fontMap;
-    
+    fontPtr->controlSubFont = fontPtr->subFontArray[0];
+    subFontPtr = FindSubFontForChar(fontPtr, '0', NULL);
+    controlPtr = &fontPtr->controlSubFont;
+    controlPtr->fontStructPtr = subFontPtr->fontStructPtr;
+    controlPtr->familyPtr = &tsdPtr->controlFamily;
+    controlPtr->fontMap = tsdPtr->controlFamily.fontMap;
+
     pageMap = fontPtr->subFontArray[0].fontMap[0];
     for (i = 0; i < 256; i++) {
-	if ((minHi > 0) || (i < minLo) || (i > maxLo) ||
-		(((pageMap[i >> 3] >> (i & 7)) & 1) == 0)) {
+	if ((minHi > 0) || (i < minLo) || (i > maxLo)
+		|| (((pageMap[i>>3] >> (i&7)) & 1) == 0)) {
 	    n = 0;
 	} else if (fontStructPtr->per_char == NULL) {
 	    n = fontStructPtr->max_bounds.width;
@@ -1503,14 +1499,13 @@ InitFont(tkwin, fontStructPtr, fontPtr)
 	}
 	fontPtr->widths[i] = n;
     }
-    
 
     if (XGetFontProperty(fontStructPtr, XA_UNDERLINE_POSITION, &value)) {
 	fontPtr->underlinePos = value;
     } else {
 	/*
-	 * If the XA_UNDERLINE_POSITION property does not exist, the X
-	 * manual recommends using the following value:
+	 * If the XA_UNDERLINE_POSITION property does not exist, the X manual
+	 * recommends using the following value:
 	 */
 
 	fontPtr->underlinePos = fontStructPtr->descent / 2;
@@ -1521,10 +1516,10 @@ InitFont(tkwin, fontStructPtr, fontPtr)
     }
     if (fontPtr->barHeight == 0) {
 	/*
-	 * If the XA_UNDERLINE_THICKNESS property does not exist, the X
-	 * manual recommends using the width of the stem on a capital
-	 * letter.  I don't know of a way to get the stem width of a letter,
-	 * so guess and use 1/3 the width of a capital I.
+	 * If the XA_UNDERLINE_THICKNESS property does not exist, the X manual
+	 * recommends using the width of the stem on a capital letter. I don't
+	 * know of a way to get the stem width of a letter, so guess and use
+	 * 1/3 the width of a capital I.
 	 */
 
 	fontPtr->barHeight = fontPtr->widths['I'] / 3;
@@ -1535,8 +1530,8 @@ InitFont(tkwin, fontStructPtr, fontPtr)
     if (fontPtr->underlinePos + fontPtr->barHeight > fontStructPtr->descent) {
 	/*
 	 * If this set of cobbled together values would cause the bottom of
-	 * the underline bar to stick below the descent of the font, jack
-	 * the underline up a bit higher.
+	 * the underline bar to stick below the descent of the font, jack the
+	 * underline up a bit higher.
 	 */
 
 	fontPtr->barHeight = fontStructPtr->descent - fontPtr->underlinePos;
@@ -1551,10 +1546,9 @@ InitFont(tkwin, fontStructPtr, fontPtr)
  *-------------------------------------------------------------------------
  *
  * ReleaseFont --
- * 
- *	Called to release the unix-specific contents of a TkFont.
- *	The caller is responsible for freeing the memory used by the
- *	font itself.
+ *
+ *	Called to release the unix-specific contents of a TkFont. The caller
+ *	is responsible for freeing the memory used by the font itself.
  *
  * Results:
  *	None.
@@ -1564,10 +1558,10 @@ InitFont(tkwin, fontStructPtr, fontPtr)
  *
  *---------------------------------------------------------------------------
  */
- 
+
 static void
-ReleaseFont(fontPtr)
-    UnixFont *fontPtr;		/* The font to delete. */
+ReleaseFont(
+    UnixFont *fontPtr)		/* The font to delete. */
 {
     int i;
 
@@ -1584,9 +1578,9 @@ ReleaseFont(fontPtr)
  *
  * InitSubFont --
  *
- *	Wrap a screen font and load the FontFamily that represents
- *	it.  Used to prepare a SubFont so that characters can be mapped
- *	from UTF-8 to the charset of the font.
+ *	Wrap a screen font and load the FontFamily that represents it. Used to
+ *	prepare a SubFont so that characters can be mapped from UTF-8 to the
+ *	charset of the font.
  *
  * Results:
  *	The subFontPtr is filled with information about the font.
@@ -1598,17 +1592,17 @@ ReleaseFont(fontPtr)
  */
 
 static void
-InitSubFont(display, fontStructPtr, base, subFontPtr)
-    Display *display;		/* Display in which font will be used. */
-    XFontStruct *fontStructPtr;	/* The screen font. */
-    int base;			/* Non-zero if this SubFont is being used
-				 * as the base font for a font object. */
-    SubFont *subFontPtr;	/* Filled with SubFont constructed from 
-    				 * above attributes. */
+InitSubFont(
+    Display *display,		/* Display in which font will be used. */
+    XFontStruct *fontStructPtr,	/* The screen font. */
+    int base,			/* Non-zero if this SubFont is being used as
+				 * the base font for a font object. */
+    SubFont *subFontPtr)	/* Filled with SubFont constructed from above
+    				 * attributes. */
 {
     subFontPtr->fontStructPtr = fontStructPtr;
-    subFontPtr->familyPtr   = AllocFontFamily(display, fontStructPtr, base);
-    subFontPtr->fontMap	    = subFontPtr->familyPtr->fontMap;
+    subFontPtr->familyPtr = AllocFontFamily(display, fontStructPtr, base);
+    subFontPtr->fontMap = subFontPtr->familyPtr->fontMap;
 }
 
 /*
@@ -1616,8 +1610,8 @@ InitSubFont(display, fontStructPtr, base, subFontPtr)
  *
  * ReleaseSubFont --
  *
- *	Called to release the contents of a SubFont.  The caller is 
- *	responsible for freeing the memory used by the SubFont itself.
+ *	Called to release the contents of a SubFont. The caller is responsible
+ *	for freeing the memory used by the SubFont itself.
  *
  * Results:
  *	None.
@@ -1629,9 +1623,9 @@ InitSubFont(display, fontStructPtr, base, subFontPtr)
  */
 
 static void
-ReleaseSubFont(display, subFontPtr)
-    Display *display;		/* Display which owns screen font. */
-    SubFont *subFontPtr;	/* The SubFont to delete. */
+ReleaseSubFont(
+    Display *display,		/* Display which owns screen font. */
+    SubFont *subFontPtr)	/* The SubFont to delete. */
 {
     XFreeFont(display, subFontPtr->fontStructPtr);
     FreeFontFamily(subFontPtr->familyPtr);
@@ -1642,42 +1636,40 @@ ReleaseSubFont(display, subFontPtr)
  *
  * AllocFontFamily --
  *
- *	Find the FontFamily structure associated with the given font
- *	name.  The information should be stored by the caller in a 
- *	SubFont and used when determining if that SubFont supports a 
- *	character.
+ *	Find the FontFamily structure associated with the given font name.
+ *	The information should be stored by the caller in a SubFont and used
+ *	when determining if that SubFont supports a character.
  *
- *	Cannot use the string name used to construct the font as the 
- *	key, because the capitalization may not be canonical.  Therefore
- *	use the face name actually retrieved from the font metrics as
- *	the key.
+ *	Cannot use the string name used to construct the font as the key,
+ *	because the capitalization may not be canonical. Therefore use the
+ *	face name actually retrieved from the font metrics as the key.
  *
  * Results:
- *	A pointer to a FontFamily.  The reference count in the FontFamily
- *	is automatically incremented.  When the SubFont is released, the
- *	reference count is decremented.  When no SubFont is using this
- *	FontFamily, it may be deleted.
+ *	A pointer to a FontFamily. The reference count in the FontFamily is
+ *	automatically incremented. When the SubFont is released, the reference
+ *	count is decremented. When no SubFont is using this FontFamily, it may
+ *	be deleted.
  *
  * Side effects:
- *	A new FontFamily structure will be allocated if this font family
- *	has not been seen.  TrueType character existence metrics are
- *	loaded into the FontFamily structure.
+ *	A new FontFamily structure will be allocated if this font family has
+ *	not been seen. TrueType character existence metrics are loaded into
+ *	the FontFamily structure.
  *
  *-------------------------------------------------------------------------
  */
 
 static FontFamily *
-AllocFontFamily(display, fontStructPtr, base)
-    Display *display;		/* Display in which font will be used. */
-    XFontStruct *fontStructPtr;	/* Screen font whose FontFamily is to be
+AllocFontFamily(
+    Display *display,		/* Display in which font will be used. */
+    XFontStruct *fontStructPtr	/* Screen font whose FontFamily is to be
 				 * returned. */
-    int base;			/* Non-zero if this font family is to be
-				 * used in the base font of a font object. */
+    int base)			/* Non-zero if this font family is to be used
+				 * in the base font of a font object. */
 {
     FontFamily *familyPtr;
     FontAttributes fa;
     Tcl_Encoding encoding;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     GetFontAttributes(display, fontStructPtr, &fa);
@@ -1699,26 +1691,26 @@ AllocFontFamily(display, fontStructPtr, base)
     familyPtr->nextPtr = tsdPtr->fontFamilyList;
     tsdPtr->fontFamilyList = familyPtr;
 
-    /* 
-     * Set key for this FontFamily. 
+    /*
+     * Set key for this FontFamily.
      */
-     
+
     familyPtr->foundry = fa.xa.foundry;
     familyPtr->faceName = fa.fa.family;
     familyPtr->encoding = encoding;
 
-    /* 
-     * An initial refCount of 2 means that FontFamily information will
-     * persist even when the SubFont that loaded the FontFamily is released.
-     * Change it to 1 to cause FontFamilies to be unloaded when not in use.
+    /*
+     * An initial refCount of 2 means that FontFamily information will persist
+     * even when the SubFont that loaded the FontFamily is released. Change it
+     * to 1 to cause FontFamilies to be unloaded when not in use.
      */
 
     familyPtr->refCount = 2;
 
     /*
-     * One byte/character fonts have both min_byte1 and max_byte1 0,
-     * and max_char_or_byte2 <= 255.
-     * Anything else specifies a two byte/character font.
+     * One byte/character fonts have both min_byte1 and max_byte1 0, and
+     * max_char_or_byte2 <= 255. Anything else specifies a two byte/character
+     * font.
      */
 
     familyPtr->isTwoByteFont = !(
@@ -1733,9 +1725,9 @@ AllocFontFamily(display, fontStructPtr, base)
  *
  * FreeFontFamily --
  *
- *	Called to free an FontFamily when the SubFont is finished using
- *	it. Frees the contents of the FontFamily and the memory used by
- *	the FontFamily itself.
+ *	Called to free an FontFamily when the SubFont is finished using it.
+ *	Frees the contents of the FontFamily and the memory used by the
+ *	FontFamily itself.
  *
  * Results:
  *	None.
@@ -1745,13 +1737,13 @@ AllocFontFamily(display, fontStructPtr, base)
  *
  *-------------------------------------------------------------------------
  */
- 
+
 static void
-FreeFontFamily(familyPtr)
-    FontFamily *familyPtr;	/* The FontFamily to delete. */
+FreeFontFamily(
+    FontFamily *familyPtr)	/* The FontFamily to delete. */
 {
     FontFamily **familyPtrPtr;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
     int i;
 
@@ -1768,11 +1760,11 @@ FreeFontFamily(familyPtr)
             ckfree(familyPtr->fontMap[i]);
         }
     }
-    
-    /* 
-     * Delete from list. 
+
+    /*
+     * Delete from list.
      */
-         
+
     for (familyPtrPtr = &tsdPtr->fontFamilyList; ; ) {
         if (*familyPtrPtr == familyPtr) {
   	    *familyPtrPtr = familyPtr->nextPtr;
@@ -1780,7 +1772,7 @@ FreeFontFamily(familyPtr)
 	}
 	familyPtrPtr = &(*familyPtrPtr)->nextPtr;
     }
-    
+
     ckfree((char *) familyPtr);
 }
 
@@ -1789,36 +1781,34 @@ FreeFontFamily(familyPtr)
  *
  * FindSubFontForChar --
  *
- *	Determine which screen font is necessary to use to 
- *	display the given character.  If the font object does not have
- *	a screen font that can display the character, another screen font
- *	may be loaded into the font object, following a set of preferred
- *	fallback rules.
+ *	Determine which screen font is necessary to use to display the given
+ *	character. If the font object does not have a screen font that can
+ *	display the character, another screen font may be loaded into the font
+ *	object, following a set of preferred fallback rules.
  *
  * Results:
- *	The return value is the SubFont to use to display the given 
- *	character. 
+ *	The return value is the SubFont to use to display the given character.
  *
  * Side effects:
- *	The contents of fontPtr are modified to cache the results
- *	of the lookup and remember any SubFonts that were dynamically 
- *	loaded.  The table of SubFonts might be extended, and if a non-NULL
- *	reference to a subfont pointer is available, it is updated if it
- *	previously pointed into the old subfont table.
+ *	The contents of fontPtr are modified to cache the results of the
+ *	lookup and remember any SubFonts that were dynamically loaded. The
+ *	table of SubFonts might be extended, and if a non-NULL reference to a
+ *	subfont pointer is available, it is updated if it previously pointed
+ *	into the old subfont table.
  *
  *-------------------------------------------------------------------------
  */
 
 static SubFont *
-FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
-    UnixFont *fontPtr;		/* The font object with which the character
+FindSubFontForChar(
+    UnixFont *fontPtr,		/* The font object with which the character
 				 * will be displayed. */
-    int ch;			/* The Unicode character to be displayed. */
-    SubFont **fixSubFontPtrPtr;	/* Subfont reference to fix up if we
+    int ch,			/* The Unicode character to be displayed. */
+    SubFont **fixSubFontPtrPtr)	/* Subfont reference to fix up if we
 				 * reallocate our subfont table. */
 {
     int i, j, k, numNames;
-    Tk_Uid faceName; 
+    Tk_Uid faceName;
     char *fallback;
     char **aliases, **nameList, **anyFallbacks;
     char ***fontFallbacks;
@@ -1840,19 +1830,19 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
     }
 
     /*
-     * Keep track of all face names that we check, so we don't check some
-     * name multiple times if it can be reached by multiple paths.
+     * Keep track of all face names that we check, so we don't check some name
+     * multiple times if it can be reached by multiple paths.
      */
-     
+
     Tcl_DStringInit(&ds);
 
     /*
-     * Are there any other fonts with the same face name as the base
-     * font that could display this character, e.g., if the base font
-     * is adobe:fixed:iso8859-1, we could might be able to use
+     * Are there any other fonts with the same face name as the base font that
+     * could display this character, e.g., if the base font is
+     * adobe:fixed:iso8859-1, we could might be able to use
      * misc:fixed:iso8859-8 or sony:fixed:jisx0208.1983-0
      */
-     
+
     faceName = fontPtr->font.fa.family;
     if (SeenName(faceName, &ds) == 0) {
 	subFontPtr = CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr);
@@ -1874,7 +1864,7 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
 
 		goto tryfallbacks;
 	    } else if (aliases != NULL) {
-		/* 
+		/*
 		 * Or if an alias for the base font has a fallback...
 		 */
 
@@ -1887,11 +1877,11 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
 	}
 	continue;
 
-	tryfallbacks:
+    tryfallbacks:
 
-	/* 
-	 * ...then see if we can use one of the fallbacks, or an
-	 * alias for one of the fallbacks.
+	/*
+	 * ...then see if we can use one of the fallbacks, or an alias for one
+	 * of the fallbacks.
 	 */
 
 	for (j = 0; (fallback = fontFallbacks[i][j]) != NULL; j++) {
@@ -1904,7 +1894,7 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
     }
 
     /*
-     * See if we can use something from the global fallback list. 
+     * See if we can use something from the global fallback list.
      */
 
     anyFallbacks = TkFontGetGlobalClass();
@@ -1917,8 +1907,8 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
     }
 
     /*
-     * Try all face names available in the whole system until we
-     * find one that can be used.
+     * Try all face names available in the whole system until we find one that
+     * can be used.
      */
 
     nameList = ListFonts(fontPtr->display, "*", &numNames);
@@ -1936,7 +1926,7 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
     }
     XFreeFontNames(nameList);
 
-    end:
+  end:
     Tcl_DStringFree(&ds);
 
     if (subFontPtr == NULL) {
@@ -1959,24 +1949,23 @@ FindSubFontForChar(fontPtr, ch, fixSubFontPtrPtr)
  *	See if the screen font can display the given character.
  *
  * Results:
- *	The return value is 0 if the screen font cannot display the
- *	character, non-zero otherwise.
+ *	The return value is 0 if the screen font cannot display the character,
+ *	non-zero otherwise.
  *
  * Side effects:
- *	New pages are added to the font mapping cache whenever the
- *	character belongs to a page that hasn't been seen before.
- *	When a page is loaded, information about all the characters on
- *	that page is stored, not just for the single character in
- *	question.
+ *	New pages are added to the font mapping cache whenever the character
+ *	belongs to a page that hasn't been seen before. When a page is loaded,
+ *	information about all the characters on that page is stored, not just
+ *	for the single character in question.
  *
  *-------------------------------------------------------------------------
  */
 
 static int
-FontMapLookup(subFontPtr, ch)
-    SubFont *subFontPtr;	/* Contains font mapping cache to be queried
+FontMapLookup(
+    SubFont *subFontPtr,	/* Contains font mapping cache to be queried
 				 * and possibly updated. */
-    int ch;			/* Character to be tested. */
+    int ch)			/* Character to be tested. */
 {
     int row, bitOffset;
 
@@ -1993,31 +1982,30 @@ FontMapLookup(subFontPtr, ch)
  *
  * FontMapInsert --
  *
- *	Tell the font mapping cache that the given screen font should be
- *	used to display the specified character.  This is called when no
- *	font on the system can be be found that can display that 
- *	character; we lie to the font and tell it that it can display
- *	the character, otherwise we would end up re-searching the entire
- *	fallback hierarchy every time that character was seen.
+ *	Tell the font mapping cache that the given screen font should be used
+ *	to display the specified character. This is called when no font on the
+ *	system can be be found that can display that character; we lie to the
+ *	font and tell it that it can display the character, otherwise we would
+ *	end up re-searching the entire fallback hierarchy every time that
+ *	character was seen.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	New pages are added to the font mapping cache whenever the
- *	character belongs to a page that hasn't been seen before.
- *	When a page is loaded, information about all the characters on
- *	that page is stored, not just for the single character in
- *	question.
+ *	New pages are added to the font mapping cache whenever the character
+ *	belongs to a page that hasn't been seen before. When a page is loaded,
+ *	information about all the characters on that page is stored, not just
+ *	for the single character in question.
  *
  *-------------------------------------------------------------------------
  */
 
 static void
-FontMapInsert(subFontPtr, ch)
-    SubFont *subFontPtr;	/* Contains font mapping cache to be 
+FontMapInsert(
+    SubFont *subFontPtr,	/* Contains font mapping cache to be
 				 * updated. */
-    int ch;			/* Character to be added to cache. */
+    int ch)			/* Character to be added to cache. */
 {
     int row, bitOffset;
 
@@ -2034,25 +2022,25 @@ FontMapInsert(subFontPtr, ch)
  *
  * FontMapLoadPage --
  *
- *	Load information about all the characters on a given page.
- *	This information consists of one bit per character that indicates
- *	whether the associated screen font can (1) or cannot (0) display
- *	the characters on the page.
+ *	Load information about all the characters on a given page. This
+ *	information consists of one bit per character that indicates whether
+ *	the associated screen font can (1) or cannot (0) display the
+ *	characters on the page.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Mempry allocated.
+ *	Memory allocated.
  *
  *-------------------------------------------------------------------------
  */
-static void 
-FontMapLoadPage(subFontPtr, row)
-    SubFont *subFontPtr;	/* Contains font mapping cache to be 
+static void
+FontMapLoadPage(
+    SubFont *subFontPtr,	/* Contains font mapping cache to be
 				 * updated. */
-    int row;			/* Index of the page to be loaded into 
-				 * the cache. */
+    int row)			/* Index of the page to be loaded into the
+				 * cache. */
 {
     char buf[16], src[TCL_UTF_MAX];
     int minHi, maxHi, minLo, maxLo, scale, checkLo;
@@ -2060,7 +2048,7 @@ FontMapLoadPage(subFontPtr, row)
     Tcl_Encoding encoding;
     XFontStruct *fontStructPtr;
     XCharStruct *widths;
-    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
             Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     subFontPtr->fontMap[row] = (char *) ckalloc(FONTMAP_BITSPERPAGE / 8);
@@ -2070,17 +2058,17 @@ FontMapLoadPage(subFontPtr, row)
 	return;
     }
 
-    fontStructPtr   = subFontPtr->fontStructPtr;
-    encoding	    = subFontPtr->familyPtr->encoding;
-    isTwoByteFont   = subFontPtr->familyPtr->isTwoByteFont;
+    fontStructPtr = subFontPtr->fontStructPtr;
+    encoding = subFontPtr->familyPtr->encoding;
+    isTwoByteFont = subFontPtr->familyPtr->isTwoByteFont;
 
-    widths	= fontStructPtr->per_char;
-    minHi	= fontStructPtr->min_byte1;
-    maxHi	= fontStructPtr->max_byte1;
-    minLo	= fontStructPtr->min_char_or_byte2;
-    maxLo	= fontStructPtr->max_char_or_byte2;
-    scale	= maxLo - minLo + 1;
-    checkLo	= minLo;
+    widths = fontStructPtr->per_char;
+    minHi = fontStructPtr->min_byte1;
+    maxHi = fontStructPtr->max_byte1;
+    minLo = fontStructPtr->min_char_or_byte2;
+    maxLo = fontStructPtr->max_char_or_byte2;
+    scale = maxLo - minLo + 1;
+    checkLo = minLo;
 
     if (! isTwoByteFont) {
 	if (minLo < 32) {
@@ -2093,7 +2081,7 @@ FontMapLoadPage(subFontPtr, row)
 	int hi, lo;
 
 	if (Tcl_UtfToExternal(NULL, encoding, src, Tcl_UniCharToUtf(i, src),
-        	TCL_ENCODING_STOPONERROR, NULL, buf, sizeof(buf), NULL, 
+        	TCL_ENCODING_STOPONERROR, NULL, buf, sizeof(buf), NULL,
 		NULL, NULL) != TCL_OK) {
 	    continue;
 	}
@@ -2108,7 +2096,7 @@ FontMapLoadPage(subFontPtr, row)
 	    continue;
 	}
 	n = (hi - minHi) * scale + lo - minLo;
-	if ((widths == NULL) || ((widths[n].width + widths[n].rbearing) != 0)) {
+	if ((widths == NULL) || (widths[n].width + widths[n].rbearing != 0)) {
 	    bitOffset = i & (FONTMAP_BITSPERPAGE - 1);
 	    subFontPtr->fontMap[row][bitOffset >> 3] |= 1 << (bitOffset & 7);
 	}
@@ -2120,43 +2108,41 @@ FontMapLoadPage(subFontPtr, row)
  *
  * CanUseFallbackWithAliases --
  *
- *	Helper function for FindSubFontForChar.  Determine if the
- *	specified face name (or an alias of the specified face name)
- *	can be used to construct a screen font that can display the
- *	given character.
+ *	Helper function for FindSubFontForChar. Determine if the specified
+ *	face name (or an alias of the specified face name) can be used to
+ *	construct a screen font that can display the given character.
  *
  * Results:
  *	See CanUseFallback().
  *
  * Side effects:
- *	If the name and/or one of its aliases was rejected, the
- *	rejected string is recorded in nameTriedPtr so that it won't
- *	be tried again.  The table of SubFonts might be extended, and if
- *	a non-NULL reference to a subfont pointer is available, it is
- *	updated if it previously pointed into the old subfont table.
+ *	If the name and/or one of its aliases was rejected, the rejected
+ *	string is recorded in nameTriedPtr so that it won't be tried again.
+ *	The table of SubFonts might be extended, and if a non-NULL reference
+ *	to a subfont pointer is available, it is updated if it previously
+ *	pointed into the old subfont table.
  *
  *---------------------------------------------------------------------------
  */
 
 static SubFont *
-CanUseFallbackWithAliases(fontPtr, faceName, ch, nameTriedPtr,
-	fixSubFontPtrPtr)
-    UnixFont *fontPtr;		/* The font object that will own the new
+CanUseFallbackWithAliases(
+    UnixFont *fontPtr,		/* The font object that will own the new
 				 * screen font. */
-    char *faceName;		/* Desired face name for new screen font. */
-    int ch;			/* The Unicode character that the new
-				 * screen font must be able to display. */
-    Tcl_DString *nameTriedPtr;	/* Records face names that have already
-				 * been tried.  It is possible for the same
-				 * face name to be queried multiple times when
+    char *faceName,		/* Desired face name for new screen font. */
+    int ch,			/* The Unicode character that the new screen
+				 * font must be able to display. */
+    Tcl_DString *nameTriedPtr,	/* Records face names that have already been
+				 * tried. It is possible for the same face
+				 * name to be queried multiple times when
 				 * trying to find a suitable screen font. */
-    SubFont **fixSubFontPtrPtr;	/* Subfont reference to fix up if we
+    SubFont **fixSubFontPtrPtr)	/* Subfont reference to fix up if we
 				 * reallocate our subfont table. */
 {
     SubFont *subFontPtr;
     char **aliases;
     int i;
-    
+
     if (SeenName(faceName, nameTriedPtr) == 0) {
 	subFontPtr = CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr);
 	if (subFontPtr != NULL) {
@@ -2183,9 +2169,9 @@ CanUseFallbackWithAliases(fontPtr, faceName, ch, nameTriedPtr,
  *
  * SeenName --
  *
- *	Used to determine we have already tried and rejected the given
- *	face name when looking for a screen font that can support some
- *	Unicode character.
+ *	Used to determine we have already tried and rejected the given face
+ *	name when looking for a screen font that can support some Unicode
+ *	character.
  *
  * Results:
  *	The return value is 0 if this face name has not already been seen,
@@ -2198,9 +2184,9 @@ CanUseFallbackWithAliases(fontPtr, faceName, ch, nameTriedPtr,
  */
 
 static int
-SeenName(name, dsPtr)
-    CONST char *name;		/* The name to check. */
-    Tcl_DString *dsPtr;		/* Contains names that have already been
+SeenName(
+    CONST char *name,		/* The name to check. */
+    Tcl_DString *dsPtr)		/* Contains names that have already been
 				 * seen. */
 {
     CONST char *seen, *end;
@@ -2222,38 +2208,36 @@ SeenName(name, dsPtr)
  *
  * CanUseFallback --
  *
- *	If the specified screen font has not already been loaded 
- *	into the font object, determine if the specified screen 
- *	font can display the given character.
+ *	If the specified screen font has not already been loaded into the font
+ *	object, determine if the specified screen font can display the given
+ *	character.
  *
  * Results:
- *	The return value is a pointer to a newly allocated SubFont,
- *	owned by the font object.  This SubFont can be used to display
- *	the given character.  The SubFont represents the screen font
- *	with the base set of font attributes from the font object, but
- *	using the specified face name.  NULL is returned if the font
- *	object already holds a reference to the specified font or if
- *	the specified font doesn't exist or cannot display the given
- *	character.
+ *	The return value is a pointer to a newly allocated SubFont, owned by
+ *	the font object. This SubFont can be used to display the given
+ *	character. The SubFont represents the screen font with the base set of
+ *	font attributes from the font object, but using the specified face
+ *	name. NULL is returned if the font object already holds a reference to
+ *	the specified font or if the specified font doesn't exist or cannot
+ *	display the given character.
  *
- * Side effects:				       
- *	The font object's subFontArray is updated to contain a reference
- *	to the newly allocated SubFont.  The table of SubFonts might be
- *	extended, and if a non-NULL reference to a subfont pointer is
- *	available, it is updated if it previously pointed into the old
- *	subfont table.
+ * Side effects:
+ *	The font object's subFontArray is updated to contain a reference to
+ *	the newly allocated SubFont. The table of SubFonts might be extended,
+ *	and if a non-NULL reference to a subfont pointer is available, it is
+ *	updated if it previously pointed into the old subfont table.
  *
  *-------------------------------------------------------------------------
  */
 
 static SubFont *
-CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
-    UnixFont *fontPtr;		/* The font object that will own the new
+CanUseFallback(
+    UnixFont *fontPtr,		/* The font object that will own the new
 				 * screen font. */
-    CONST char *faceName;	/* Desired face name for new screen font. */
-    int ch;			/* The Unicode character that the new
-				 * screen font must be able to display. */
-    SubFont **fixSubFontPtrPtr;	/* Subfont reference to fix up if we
+    CONST char *faceName,	/* Desired face name for new screen font. */
+    int ch,			/* The Unicode character that the new screen
+				 * font must be able to display. */
+    SubFont **fixSubFontPtrPtr)	/* Subfont reference to fix up if we
 				 * reallocate our subfont table. */
 {
     int i, nameIdx, numNames, srcLen;
@@ -2275,16 +2259,15 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
      * Assume: the face name is times.
      * Assume: adobe:times:iso8859-1 has already been used.
      *
-     * Are there any versions of times that can display this
-     *    character (e.g., perhaps linotype:times:iso8859-2)?
+     * Are there any versions of times that can display this character (e.g.,
+     *    perhaps linotype:times:iso8859-2)?
      *	  a. Get list of all times fonts.
      *	  b1. Cross out all names whose encodings we've already used.
      *	  b2. Cross out all names whose foundry & encoding we've already seen.
      *	  c. Cross out all names whose encoding cannot handle the character.
      *	  d. Rank each name and pick the best match.
-     *	  e. If that font cannot actually display the character, cross
-     *	     out all names with the same foundry and encoding and go
-     *	     back to (c).
+     *	  e. If that font cannot actually display the character, cross out all
+     *	     names with the same foundry and encoding and go back to (c).
      */
 
     display = fontPtr->display;
@@ -2309,7 +2292,7 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 
     charset = NULL;	/* lint, since numNames must be > 0 to get here. */
 
-    retry:
+  retry:
     bestIdx[0] = -1;
     bestIdx[1] = -1;
     bestScore[0] = (unsigned int) -1;
@@ -2319,7 +2302,7 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 	char dst[16];
 	int scalable, srcRead, dstWrote;
 	unsigned int score;
-	
+
 	if (nameList[nameIdx] == NULL) {
 	    continue;
 	}
@@ -2330,9 +2313,8 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 	charset = GetEncodingAlias(got.xa.charset);
 	if (hateFoundry != NULL) {
 	    /*
-	     * E. If the font we picked cannot actually display the
-	     * character, cross out all names with the same foundry and
-	     * encoding. 
+	     * E. If the font we picked cannot actually display the character,
+	     * cross out all names with the same foundry and encoding.
 	     */
 
 	    if ((hateFoundry == got.xa.foundry)
@@ -2343,7 +2325,7 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 	    /*
 	     * B. Cross out all names whose encodings we've already used.
 	     */
-	     
+
 	    for (i = 0; i < fontPtr->numSubFonts; i++) {
 		encoding = fontPtr->subFontArray[i].familyPtr->encoding;
 		if (strcmp(charset, Tcl_GetEncodingName(encoding)) == 0) {
@@ -2351,11 +2333,11 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 		}
 	    }
 	}
-	
+
 	/*
 	 * C. Cross out all names whose encoding cannot handle the character.
 	 */
-	 
+
 	encodingCachePtr = (Tcl_Encoding *) Tcl_DStringValue(&dsEncodings);
 	for (i = numEncodings; --i >= 0; encodingCachePtr++) {
 	    encoding = *encodingCachePtr;
@@ -2373,8 +2355,8 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 		    sizeof(encoding));
 	    numEncodings++;
 	}
-	Tcl_UtfToExternal(NULL, encoding, src, srcLen, 
-		TCL_ENCODING_STOPONERROR, NULL, dst, sizeof(dst), &srcRead, 
+	Tcl_UtfToExternal(NULL, encoding, src, srcLen,
+		TCL_ENCODING_STOPONERROR, NULL, dst, sizeof(dst), &srcRead,
 		&dstWrote, NULL);
 	if (dstWrote == 0) {
 	    goto crossout;
@@ -2395,11 +2377,11 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 	}
 	continue;
 
-	crossout:
+    crossout:
 	if (nameList == nameListOrig) {
 	    /*
-	     * Not allowed to change pointers to memory that X gives you,
-	     * so make a copy.
+	     * Not allowed to change pointers to memory that X gives you, so
+	     * make a copy.
 	     */
 
 	    nameList = (char **) ckalloc(numNames * sizeof(char *));
@@ -2408,7 +2390,8 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 	nameList[nameIdx] = NULL;
     }
 
-    fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx, bestScore);
+    fontStructPtr = GetScreenFont(display, &want, nameList, bestIdx,
+	    bestScore);
 
     encodingCachePtr = (Tcl_Encoding *) Tcl_DStringValue(&dsEncodings);
     for (i = numEncodings; --i >= 0; encodingCachePtr++) {
@@ -2445,8 +2428,9 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
 
     if (fontPtr->numSubFonts >= SUBFONT_SPACE) {
 	SubFont *newPtr;
-	
-	newPtr = (SubFont *) ckalloc(sizeof(SubFont) * (fontPtr->numSubFonts + 1));
+
+	newPtr = (SubFont *)
+		ckalloc(sizeof(SubFont) * (fontPtr->numSubFonts + 1));
 	memcpy((char *) newPtr, fontPtr->subFontArray,
 		fontPtr->numSubFonts * sizeof(SubFont));
 	if (fixSubFontPtrPtr != NULL) {
@@ -2472,12 +2456,12 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
  *
  * RankAttributes --
  *
- *	Determine how close the attributes of the font in question match
- *	the attributes that we want.
+ *	Determine how close the attributes of the font in question match the
+ *	attributes that we want.
  *
  * Results:
- *	The return value is the score; lower numbers are better.
- *	*scalablePtr is set to 0 if the font was not scalable, 1 otherwise.
+ *	The return value is the score; lower numbers are better. *scalablePtr
+ *	is set to 0 if the font was not scalable, 1 otherwise.
  *
  * Side effects:
  *	None.
@@ -2486,9 +2470,9 @@ CanUseFallback(fontPtr, faceName, ch, fixSubFontPtrPtr)
  */
 
 static unsigned int
-RankAttributes(wantPtr, gotPtr)
-    FontAttributes *wantPtr;	/* The desired attributes. */
-    FontAttributes *gotPtr;	/* The attributes we have to live with. */
+RankAttributes(
+    FontAttributes *wantPtr,	/* The desired attributes. */
+    FontAttributes *gotPtr)	/* The attributes we have to live with. */
 {
     unsigned int penalty;
 
@@ -2514,8 +2498,8 @@ RankAttributes(wantPtr, gotPtr)
 
     if (gotPtr->fa.size == 0) {
 	/*
-	 * A scalable font is almost always acceptable, but the
-	 * corresponding bitmapped font would be better.
+	 * A scalable font is almost always acceptable, but the corresponding
+	 * bitmapped font would be better.
 	 */
 
 	penalty += 10;
@@ -2525,7 +2509,7 @@ RankAttributes(wantPtr, gotPtr)
 	/*
 	 * It's worse to be too large than to be too small.
 	 */
-	 
+
 	diff = (-gotPtr->fa.size - -wantPtr->fa.size);
 	if (diff > 0) {
 	    penalty += 600;
@@ -2541,7 +2525,7 @@ RankAttributes(wantPtr, gotPtr)
 
 	penalty += 65000;
 	gotAlias = GetEncodingAlias(gotPtr->xa.charset);
-	wantAlias = GetEncodingAlias(wantPtr->xa.charset); 
+	wantAlias = GetEncodingAlias(wantPtr->xa.charset);
 	if (strcmp(gotAlias, wantAlias) != 0) {
 	    penalty += 30000;
 	    for (i = 0; encodingList[i] != NULL; i++) {
@@ -2562,9 +2546,8 @@ RankAttributes(wantPtr, gotPtr)
  * GetScreenFont --
  *
  *	Given the names for the best scalable and best bitmapped font,
- *	actually construct an XFontStruct based on the best XLFD.
- *	This is where all the alias and fallback substitution bottoms
- *	out.
+ *	actually construct an XFontStruct based on the best XLFD. This is
+ *	where all the alias and fallback substitution bottoms out.
  *
  * Results:
  *	The screen font that best corresponds to the set of attributes.
@@ -2576,16 +2559,16 @@ RankAttributes(wantPtr, gotPtr)
  */
 
 static XFontStruct *
-GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
-    Display *display;		/* Display for new XFontStruct. */
-    FontAttributes *wantPtr;	/* Contains desired actual pixel-size if the
+GetScreenFont(
+    Display *display,		/* Display for new XFontStruct. */
+    FontAttributes *wantPtr,	/* Contains desired actual pixel-size if the
 				 * best font was scalable. */
-    char **nameList;		/* Array of XLFDs. */
-    int bestIdx[2];		/* Indices into above array for XLFD of
-				 * best bitmapped and best scalable font. */
-    unsigned int bestScore[2];	/* Scores of best bitmapped and best
-				 * scalable font.  XLFD corresponding to
-				 * lowest score will be constructed. */
+    char **nameList,		/* Array of XLFDs. */
+    int bestIdx[2],		/* Indices into above array for XLFD of best
+				 * bitmapped and best scalable font. */
+    unsigned int bestScore[2])	/* Scores of best bitmapped and best scalable
+				 * font. XLFD corresponding to lowest score
+				 * will be constructed. */
 {
     XFontStruct *fontStructPtr;
 
@@ -2594,11 +2577,11 @@ GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
     }
 
     /*
-     * Now we know which is the closest matching scalable font and the
-     * closest matching bitmapped font.  If the scalable font was a
-     * better match, try getting the scalable font; however, if the
-     * scalable font was not actually available in the desired
-     * pointsize, fall back to the closest bitmapped font.
+     * Now we know which is the closest matching scalable font and the closest
+     * matching bitmapped font. If the scalable font was a better match, try
+     * getting the scalable font; however, if the scalable font was not
+     * actually available in the desired pointsize, fall back to the closest
+     * bitmapped font.
      */
 
     fontStructPtr = NULL;
@@ -2606,12 +2589,12 @@ GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
 	char *str, *rest;
 	char buf[256];
 	int i;
-	
+
 	/*
 	 * Fill in the desired pixel size for this font.
 	 */
 
-	tryscale:
+    tryscale:
 	str = nameList[bestIdx[1]];
 	for (i = 0; i < XLFD_PIXEL_SIZE; i++) {
 	    str = strchr(str + 1, '-');
@@ -2631,8 +2614,8 @@ GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
 	fontStructPtr = XLoadQueryFont(display, nameList[bestIdx[0]]);
 	if (fontStructPtr == NULL) {
 	    /*
-	     * This shouldn't happen because the font name is one of the
-	     * names that X gave us to use, but it does anyhow.
+	     * This shouldn't happen because the font name is one of the names
+	     * that X gave us to use, but it does anyhow.
 	     */
 
 	    if (bestScore[1] < INT_MAX) {
@@ -2649,22 +2632,22 @@ GetScreenFont(display, wantPtr, nameList, bestIdx, bestScore)
  *
  * GetSystemFont --
  *
- *	Absolute fallback mechanism, called when we need a font and no
- *	other font can be found and/or instantiated.
+ *	Absolute fallback mechanism, called when we need a font and no other
+ *	font can be found and/or instantiated.
  *
  * Results:
- *	A pointer to a font.  Never NULL.
+ *	A pointer to a font. Never NULL.
  *
  * Side effects:
- *	If there are NO fonts installed on the system, this call will
- *	panic, but how did you get X running in that case?
+ *	If there are NO fonts installed on the system, this call will panic,
+ *	but how did you get X running in that case?
  *
  *---------------------------------------------------------------------------
  */
 
 static XFontStruct *
-GetSystemFont(display)
-    Display *display;		/* Display for new XFontStruct. */
+GetSystemFont(
+    Display *display)		/* Display for new XFontStruct. */
 {
     XFontStruct *fontStructPtr;
 
@@ -2683,8 +2666,8 @@ GetSystemFont(display)
  *
  * GetFontAttributes --
  *
- *	Given a screen font, determine its actual attributes, which are
- *	not necessarily the attributes that were used to construct it.
+ *	Given a screen font, determine its actual attributes, which are not
+ *	necessarily the attributes that were used to construct it.
  *
  * Results:
  *	*faPtr is filled with the screen font's attributes.
@@ -2696,14 +2679,14 @@ GetSystemFont(display)
  */
 
 static int
-GetFontAttributes(display, fontStructPtr, faPtr)
-    Display *display;		/* Display that owns the screen font. */
-    XFontStruct *fontStructPtr;	/* Screen font to query. */
-    FontAttributes *faPtr;	/* For storing attributes of screen font. */
+GetFontAttributes(
+    Display *display,		/* Display that owns the screen font. */
+    XFontStruct *fontStructPtr,	/* Screen font to query. */
+    FontAttributes *faPtr)	/* For storing attributes of screen font. */
 {
     unsigned long value;
     char *name;
-    
+
     if ((XGetFontProperty(fontStructPtr, XA_FONT, &value) != False) &&
 	    (value != 0)) {
 	name = XGetAtomName(display, (Atom) value);
@@ -2717,11 +2700,13 @@ GetFontAttributes(display, fontStructPtr, faPtr)
 	TkInitFontAttributes(&faPtr->fa);
 	TkInitXLFDAttributes(&faPtr->xa);
     }
+
     /*
-     * Do last ditch check for family.  It seems that some X servers can
-     * fail on the X font calls above, slipping through earlier checks.
-     * X-Win32 5.4 is one of these.
+     * Do last ditch check for family. It seems that some X servers can fail
+     * on the X font calls above, slipping through earlier checks. X-Win32 5.4
+     * is one of these.
      */
+
     if (faPtr->fa.family == NULL) {
 	faPtr->fa.family = Tk_GetUid("");
 	faPtr->xa.foundry = Tk_GetUid("");
@@ -2735,8 +2720,8 @@ GetFontAttributes(display, fontStructPtr, faPtr)
  *
  * ListFonts --
  *
- *	Utility function to return the array of all XLFDs on the system
- *	with the specified face name.
+ *	Utility function to return the array of all XLFDs on the system with
+ *	the specified face name.
  *
  * Results:
  *	The return value is an array of XLFDs, which should be freed with
@@ -2747,13 +2732,13 @@ GetFontAttributes(display, fontStructPtr, faPtr)
  *
  *---------------------------------------------------------------------------
  */
- 
+
 static char **
-ListFonts(display, faceName, numNamesPtr)
-    Display *display;		/* Display to query. */
-    CONST char *faceName;	/* Desired face name, or "*" for all. */
-    int *numNamesPtr;		/* Filled with length of returned array, or
-				 * 0 if no names were found. */
+ListFonts(
+    Display *display,		/* Display to query. */
+    CONST char *faceName,	/* Desired face name, or "*" for all. */
+    int *numNamesPtr)		/* Filled with length of returned array, or 0
+				 * if no names were found. */
 {
     char buf[256];
 
@@ -2762,15 +2747,15 @@ ListFonts(display, faceName, numNamesPtr)
 }
 
 static char **
-ListFontOrAlias(display, faceName, numNamesPtr)
-    Display *display;		/* Display to query. */
-    CONST char *faceName;	/* Desired face name, or "*" for all. */
-    int *numNamesPtr;		/* Filled with length of returned array, or
-				 * 0 if no names were found. */
+ListFontOrAlias(
+    Display *display,		/* Display to query. */
+    CONST char *faceName,	/* Desired face name, or "*" for all. */
+    int *numNamesPtr)		/* Filled with length of returned array, or 0
+				 * if no names were found. */
 {
     char **nameList, **aliases;
     int i;
-    
+
     nameList = ListFonts(display, faceName, numNamesPtr);
     if (nameList != NULL) {
 	return nameList;
@@ -2793,19 +2778,18 @@ ListFontOrAlias(display, faceName, numNamesPtr)
  *
  * IdentifySymbolEncodings --
  *
- *	If the font attributes refer to a symbol font, update the
- *	charset field of the font attributes so that it reflects the
- *	encoding of that symbol font.  In general, the raw value for
- *	the charset field parsed from an XLFD is meaningless for symbol
- *	fonts.
+ *	If the font attributes refer to a symbol font, update the charset
+ *	field of the font attributes so that it reflects the encoding of that
+ *	symbol font. In general, the raw value for the charset field parsed
+ *	from an XLFD is meaningless for symbol fonts.
  *
  *	Symbol fonts are all fonts whose name appears in the symbolClass.
  *
  * Results:
- *	The return value is non-zero if the font attributes specify a
- *	symbol font, or 0 otherwise.  If a non-zero value is returned
- *	the charset field of the font attributes will be changed to
- *	the string that represents the actual encoding for the symbol font.
+ *	The return value is non-zero if the font attributes specify a symbol
+ *	font, or 0 otherwise. If a non-zero value is returned the charset
+ *	field of the font attributes will be changed to the string that
+ *	represents the actual encoding for the symbol font.
  *
  * Side effects:
  *	None.
@@ -2814,8 +2798,8 @@ ListFontOrAlias(display, faceName, numNamesPtr)
  */
 
 static int
-IdentifySymbolEncodings(faPtr)
-    FontAttributes *faPtr;
+IdentifySymbolEncodings(
+    FontAttributes *faPtr)
 {
     int i, j;
     char **aliases, **symbolClass;
@@ -2842,14 +2826,14 @@ IdentifySymbolEncodings(faPtr)
  *
  * GetEncodingAlias --
  *
- *	Map the name of an encoding to another name that should be used
- *	when actually loading the encoding.  For instance, the encodings
- *	"jisc6226.1978", "jisx0208.1983", "jisx0208.1990", and
- *	"jisx0208.1996" are well-known names for the same encoding and
- *	are represented by one encoding table: "jis0208".
+ *	Map the name of an encoding to another name that should be used when
+ *	actually loading the encoding. For instance, the encodings
+ *	"jisc6226.1978", "jisx0208.1983", "jisx0208.1990", and "jisx0208.1996"
+ *	are well-known names for the same encoding and are represented by one
+ *	encoding table: "jis0208".
  *
  * Results:
- *	As above.  If the name has no alias, the original name is returned.
+ *	As above. If the name has no alias, the original name is returned.
  *
  * Side effects:
  *	None.
@@ -2858,11 +2842,11 @@ IdentifySymbolEncodings(faPtr)
  */
 
 static CONST char *
-GetEncodingAlias(name)
-    CONST char *name;		/* The name to look up. */
+GetEncodingAlias(
+    CONST char *name)		/* The name to look up. */
 {
     EncodingAlias *aliasPtr;
-    
+
     for (aliasPtr = encodingAliases; aliasPtr->aliasPattern != NULL; ) {
 	if (Tcl_StringMatch((char *) name, aliasPtr->aliasPattern)) {
 	    return aliasPtr->realName;
@@ -2871,3 +2855,11 @@ GetEncodingAlias(name)
     }
     return name;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixInit.c b/unix/tkUnixInit.c
index 05dcc49..4fbef46 100644
--- a/unix/tkUnixInit.c
+++ b/unix/tkUnixInit.c
@@ -1,31 +1,31 @@
-/* 
+/*
  * tkUnixInit.c --
  *
- *	This file contains Unix-specific interpreter initialization
- *	functions.
+ *	This file contains Unix-specific interpreter initialization functions.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixInit.c,v 1.6 2005/05/23 20:25:04 das Exp $
+ * RCS: @(#) $Id: tkUnixInit.c,v 1.7 2005/11/14 11:54:21 dkf Exp $
  */
 
 #include "tkInt.h"
 #include "tkUnixInt.h"
 
 /*
- * The Init script (common to Windows and Unix platforms) is
- * defined in tkInitScript.h
+ * The Init script (common to Windows and Unix platforms) is defined in
+ * tkInitScript.h
  */
+
 #include "tkInitScript.h"
 
 #ifdef HAVE_COREFOUNDATION
-static int		MacOSXGetLibraryPath _ANSI_ARGS_((
-			    Tcl_Interp *interp));
+static int		GetLibraryPath(Tcl_Interp *interp);
+#else
+#define GetLibraryPath(dummy)	(void)0
 #endif /* HAVE_COREFOUNDATION */
-
 
 /*
  *----------------------------------------------------------------------
@@ -36,8 +36,8 @@ static int		MacOSXGetLibraryPath _ANSI_ARGS_((
  *      tk_library variable.
  *
  * Results:
- *	Returns a standard Tcl result.  Leaves an error message or result
- *	in the interp's result.
+ *	Returns a standard Tcl result. Leaves an error message or result in
+ *	the interp's result.
  *
  * Side effects:
  *	Sets "tk_library" Tcl variable, runs "tk.tcl" script.
@@ -46,13 +46,11 @@ static int		MacOSXGetLibraryPath _ANSI_ARGS_((
  */
 
 int
-TkpInit(interp)
-    Tcl_Interp *interp;
+TkpInit(
+    Tcl_Interp *interp)
 {
     TkCreateXEventSource();
-#ifdef HAVE_COREFOUNDATION
-    MacOSXGetLibraryPath(interp);
-#endif /* HAVE_COREFOUNDATION */
+    GetLibraryPath(interp);
     return Tcl_Eval(interp, initScript);
 }
 
@@ -61,9 +59,9 @@ TkpInit(interp)
  *
  * TkpGetAppName --
  *
- *	Retrieves the name of the current application from a platform
- *	specific location.  For Unix, the application name is the tail
- *	of the path contained in the tcl variable argv0.
+ *	Retrieves the name of the current application from a platform specific
+ *	location. For Unix, the application name is the tail of the path
+ *	contained in the tcl variable argv0.
  *
  * Results:
  *	Returns the application name in the given Tcl_DString.
@@ -75,9 +73,9 @@ TkpInit(interp)
  */
 
 void
-TkpGetAppName(interp, namePtr)
-    Tcl_Interp *interp;
-    Tcl_DString *namePtr;	/* A previously initialized Tcl_DString. */
+TkpGetAppName(
+    Tcl_Interp *interp,
+    Tcl_DString *namePtr)	/* A previously initialized Tcl_DString. */
 {
     CONST char *p, *name;
 
@@ -98,8 +96,8 @@ TkpGetAppName(interp, namePtr)
  *
  * TkpDisplayWarning --
  *
- *	This routines is called from Tk_Main to display warning
- *	messages that occur during startup.
+ *	This routines is called from Tk_Main to display warning messages that
+ *	occur during startup.
  *
  * Results:
  *	None.
@@ -111,9 +109,9 @@ TkpGetAppName(interp, namePtr)
  */
 
 void
-TkpDisplayWarning(msg, title)
-    CONST char *msg;		/* Message to be displayed. */
-    CONST char *title;		/* Title of warning. */
+TkpDisplayWarning(
+    CONST char *msg,		/* Message to be displayed. */
+    CONST char *title)		/* Title of warning. */
 {
     Tcl_Channel errChannel = Tcl_GetStdChannel(TCL_STDERR);
     if (errChannel) {
@@ -124,14 +122,15 @@ TkpDisplayWarning(msg, title)
     }
 }
 
+#ifdef HAVE_COREFOUNDATION
+
 /*
  *----------------------------------------------------------------------
  *
- * MacOSXGetLibraryPath --
+ * GetLibraryPath --
  *
- *	If we have a bundle structure for the Tk installation,
- *	then check there first to see if we can find the libraries
- *	there.
+ *	If we have a bundle structure for the Tk installation, then check
+ *	there first to see if we can find the libraries there.
  *
  * Results:
  *	TCL_OK if we have found the tk library; TCL_ERROR otherwise.
@@ -142,19 +141,31 @@ TkpDisplayWarning(msg, title)
  *----------------------------------------------------------------------
  */
 
-#ifdef HAVE_COREFOUNDATION
 static int
-MacOSXGetLibraryPath(Tcl_Interp *interp)
+GetLibraryPath(
+    Tcl_Interp *interp)
 {
-    int foundInFramework = TCL_ERROR;
 #ifdef TK_FRAMEWORK
+    int foundInFramework = TCL_ERROR;
     char tkLibPath[PATH_MAX + 1];
-    foundInFramework = Tcl_MacOSXOpenVersionedBundleResources(interp, 
-	"com.tcltk.tklibrary", TK_FRAMEWORK_VERSION, 0, PATH_MAX, tkLibPath);
+
+    foundInFramework = Tcl_MacOSXOpenVersionedBundleResources(interp,
+	    "com.tcltk.tklibrary", TK_FRAMEWORK_VERSION, 0, PATH_MAX,
+	    tkLibPath);
     if (tkLibPath[0] != '\0') {
         Tcl_SetVar(interp, "tk_library", tkLibPath, TCL_GLOBAL_ONLY);
     }
-#endif
     return foundInFramework;
+#else
+    return TCL_ERROR;
+#endif
 }
 #endif /* HAVE_COREFOUNDATION */
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixRFont.c b/unix/tkUnixRFont.c
index cd4a4f0..aa41afc 100644
--- a/unix/tkUnixRFont.c
+++ b/unix/tkUnixRFont.c
@@ -5,10 +5,10 @@
  *
  * Copyright (c) 2002-2003 Keith Packard
  *
- * 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: tkUnixRFont.c,v 1.9 2005/04/19 05:50:06 jenglish Exp $
+ * RCS: @(#) $Id: tkUnixRFont.c,v 1.10 2005/11/14 11:54:21 dkf Exp $
  */
 
 #include "tkUnixInt.h"
@@ -16,32 +16,40 @@
 #include <X11/Xft/Xft.h>
 #include <ctype.h>
 
-typedef struct _UnixFtFace {
-    XftFont	    *ftFont;
-    FcPattern	    *source;
-    FcCharSet	    *charset;
+typedef struct {
+    XftFont *ftFont;
+    FcPattern *source;
+    FcCharSet *charset;
 } UnixFtFace;
 
-typedef struct _UnixFtFont {
-    TkFont	    font;    	/* Stuff used by generic font package.  Must
-				 * be first in structure. */
-    UnixFtFace	    *faces;
-    int		    nfaces;
-    FcCharSet	    *charset;
-    FcPattern	    *pattern;
-    
-    Display	    *display;
-    int		    screen;
-    XftDraw	    *ftDraw;
-    Drawable	    drawable;
-    XftColor	    color;
+typedef struct {
+    TkFont font;	    	/* Stuff used by generic font package. Must be
+				 * first in structure. */
+    UnixFtFace *faces;
+    int nfaces;
+    FcCharSet *charset;
+    FcPattern *pattern;
+
+    Display *display;
+    int screen;
+    XftDraw *ftDraw;
+    Drawable drawable;
+    XftColor color;
 } UnixFtFont;
 
+/*
+ * Forward declarations...
+ */
 
+static XftFont *	GetFont(UnixFtFont *fontPtr, FcChar32 ucs4);
+static UnixFtFont *	InitFont(Tk_Window tkwin, FcPattern *pattern,
+			    UnixFtFont *fontPtr);
+static void		FinishedWithFont(UnixFtFont *fontPtr);
+
 /*
  * Package initialization:
- * 	Nothing to do here except register the fact that we're using Xft
- * 	in the TIP 59 configuration database. 
+ * 	Nothing to do here except register the fact that we're using Xft in
+ * 	the TIP 59 configuration database.
  */
 
 #ifndef TCL_CFGVAL_ENCODING
@@ -54,16 +62,16 @@ static Tcl_Config cfg[] = {
 };
 
 void
-TkpFontPkgInit(mainPtr)
-    TkMainInfo *mainPtr;	/* The application being created. */
+TkpFontPkgInit(
+    TkMainInfo *mainPtr)	/* The application being created. */
 {
     Tcl_RegisterConfig(mainPtr->interp, "tk", cfg, TCL_CFGVAL_ENCODING);
 }
 
 static XftFont *
-GetFont(fontPtr, ucs4)
-    UnixFtFont *fontPtr;
-    FcChar32 ucs4;
+GetFont(
+    UnixFtFont *fontPtr,
+    FcChar32 ucs4)
 {
     int i;
 
@@ -94,21 +102,20 @@ GetFont(fontPtr, ucs4)
  *
  * InitFont --
  *
- *	Initializes the fields of a UnixFtFont structure.
- *	If fontPtr is NULL, also allocates a new UnixFtFont.
- * 
+ *	Initializes the fields of a UnixFtFont structure. If fontPtr is NULL,
+ *	also allocates a new UnixFtFont.
+ *
  * Results:
- * 	On error, frees fontPtr and returns NULL, otherwise
- * 	returns fontPtr.
+ * 	On error, frees fontPtr and returns NULL, otherwise returns fontPtr.
  *
  *---------------------------------------------------------------------------
  */
 
 static UnixFtFont *
-InitFont(tkwin, pattern, fontPtr)
-    Tk_Window tkwin;
-    FcPattern *pattern;
-    UnixFtFont *fontPtr;
+InitFont(
+    Tk_Window tkwin,
+    FcPattern *pattern,
+    UnixFtFont *fontPtr)
 {
     TkFontAttributes *faPtr;
     TkFontMetrics *fmPtr;
@@ -119,20 +126,21 @@ InitFont(tkwin, pattern, fontPtr)
     FcCharSet *charset;
     FcResult result;
     XftFont *ftFont;
-    
+
     if (!fontPtr) {
 	fontPtr = (UnixFtFont *) ckalloc(sizeof(UnixFtFont));
     }
     if (!fontPtr) {
 	return NULL; /* Never called? */
     }
-    
+
     FcConfigSubstitute(0, pattern, FcMatchPattern);
     XftDefaultSubstitute(Tk_Display(tkwin), Tk_ScreenNumber(tkwin), pattern);
 
     /*
      * Generate the list of fonts
      */
+
     set = FcFontSort(0, pattern, FcTrue, &charset, &result);
 
     if (!set) {
@@ -143,7 +151,7 @@ InitFont(tkwin, pattern, fontPtr)
 
     fontPtr->charset = charset;
     fontPtr->pattern = pattern;
-    
+
     fontPtr->faces = (UnixFtFace *) ckalloc(set->nfont * sizeof(UnixFtFace));
     if (!fontPtr->faces) {
 	FcFontSetDestroy(set);
@@ -153,10 +161,11 @@ InitFont(tkwin, pattern, fontPtr)
 	return NULL;
     }
     fontPtr->nfaces = set->nfont;
-    
+
     /*
      * Fill in information about each returned font
      */
+
     for (i = 0; i < set->nfont; i++) {
 	fontPtr->faces[i].ftFont = 0;
 	fontPtr->faces[i].source = set->fonts[i];
@@ -184,11 +193,12 @@ InitFont(tkwin, pattern, fontPtr)
     /*
      * Build the Tk font structure
      */
+
     if (XftPatternGetString(ftFont->pattern, XFT_FAMILY, 0,
 	    &family) != XftResultMatch) {
 	family = "Unknown";
     }
-    
+
     if (XftPatternGetInteger(ftFont->pattern, XFT_WEIGHT, 0,
 	    &weight) != XftResultMatch) {
 	weight = XFT_WEIGHT_MEDIUM;
@@ -198,7 +208,7 @@ InitFont(tkwin, pattern, fontPtr)
     } else {
 	weight = TK_FW_BOLD;
     }
-    
+
     if (XftPatternGetInteger(ftFont->pattern, XFT_SLANT, 0,
 	    &slant) != XftResultMatch) {
 	slant = XFT_SLANT_ROMAN;
@@ -208,12 +218,12 @@ InitFont(tkwin, pattern, fontPtr)
     } else {
 	slant = TK_FS_ITALIC;
     }
-    
+
     if (XftPatternGetDouble(ftFont->pattern, XFT_SIZE, 0,
 	    &size) != XftResultMatch) {
 	size = 12.0;
     }
-    
+
     if (XftPatternGetInteger(ftFont->pattern, XFT_SPACING, 0,
 	    &spacing) != XftResultMatch) {
 	spacing = XFT_PROPORTIONAL;
@@ -226,7 +236,7 @@ InitFont(tkwin, pattern, fontPtr)
 #if DEBUG_FONTSEL
     printf("family %s size %g weight %d slant %d\n",
 	    family, size, weight, slant);
-#endif
+#endif /* DEBUG_FONTSEL */
 
     faPtr = &fontPtr->font.fa;
     faPtr->family = family;
@@ -246,15 +256,15 @@ InitFont(tkwin, pattern, fontPtr)
 }
 
 static void
-FiniFont(fontPtr)
-    UnixFtFont *fontPtr;
+FinishedWithFont(
+    UnixFtFont *fontPtr)
 {
     Display *display = fontPtr->display;
     Tk_ErrorHandler handler;
     int i;
 
     handler = Tk_CreateErrorHandler(display, -1, -1, -1,
-	    (Tk_ErrorProc *) NULL, (ClientData) NULL);
+	    NULL, (ClientData) NULL);
     for (i = 0; i < fontPtr->nfaces; i++) {
 	if (fontPtr->faces[i].ftFont) {
 	    XftFontClose(fontPtr->display, fontPtr->faces[i].ftFont);
@@ -276,15 +286,15 @@ FiniFont(fontPtr)
 }
 
 TkFont *
-TkpGetNativeFont(tkwin, name)
-    Tk_Window tkwin;		/* For display where font will be used. */
-    CONST char *name;		/* Platform-specific font name. */
+TkpGetNativeFont(
+    Tk_Window tkwin,		/* For display where font will be used. */
+    CONST char *name)		/* Platform-specific font name. */
 {
     UnixFtFont *fontPtr;
     FcPattern *pattern;
 #if DEBUG_FONTSEL
     printf("TkpGetNativeFont %s\n", name);
-#endif
+#endif /* DEBUG_FONTSEL */
 
     pattern = XftXlfdParse(name, FcFalse, FcFalse);
     if (!pattern) {
@@ -292,9 +302,8 @@ TkpGetNativeFont(tkwin, name)
     }
 
     /*
-     * Should also try: pattern = FcNameParse(name);
-     * but generic/tkFont.c expects TkpGetNativeFont() to only
-     * work on XLFD names under Unix.
+     * Should also try: pattern = FcNameParse(name); but generic/tkFont.c
+     * expects TkpGetNativeFont() to only work on XLFD names under Unix.
      */
 
     fontPtr = InitFont(tkwin, pattern, NULL);
@@ -305,15 +314,15 @@ TkpGetNativeFont(tkwin, name)
 }
 
 TkFont *
-TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
-    TkFont *tkFontPtr;		/* If non-NULL, store the information in
-				 * this existing TkFont structure, rather than
+TkpGetFontFromAttributes(
+    TkFont *tkFontPtr,		/* If non-NULL, store the information in this
+				 * existing TkFont structure, rather than
 				 * allocating a new structure to hold the
 				 * font; the existing contents of the font
-				 * will be released.  If NULL, a new TkFont
+				 * will be released. If NULL, a new TkFont
 				 * structure is allocated. */
-    Tk_Window tkwin;		/* For display where font will be used. */
-    CONST TkFontAttributes *faPtr;
+    Tk_Window tkwin,		/* For display where font will be used. */
+    CONST TkFontAttributes *faPtr)
 				/* Set of attributes to match. */
 {
     XftPattern *pattern;
@@ -323,7 +332,7 @@ TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
 #if DEBUG_FONTSEL
     printf("TkpGetFontFromAttributes %s-%d %d %d\n", faPtr->family,
 	    faPtr->size, faPtr->weight, faPtr->slant);
-#endif
+#endif /* DEBUG_FONTSEL */
     pattern = XftPatternCreate();
     if (faPtr->family) {
 	XftPatternAddString(pattern, XFT_FAMILY, faPtr->family);
@@ -361,7 +370,7 @@ TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
 
     fontPtr = (UnixFtFont *) tkFontPtr;
     if (fontPtr != NULL) {
-	FiniFont(fontPtr);
+	FinishedWithFont(fontPtr);
     }
     fontPtr = InitFont(tkwin, pattern, fontPtr);
     if (!fontPtr) {
@@ -371,12 +380,12 @@ TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr)
 }
 
 void
-TkpDeleteFont(tkFontPtr)
-    TkFont *tkFontPtr;		/* Token of font to be deleted. */
+TkpDeleteFont(
+    TkFont *tkFontPtr)		/* Token of font to be deleted. */
 {
     UnixFtFont *fontPtr = (UnixFtFont *) tkFontPtr;
 
-    FiniFont(fontPtr);
+    FinishedWithFont(fontPtr);
     /* XXX tkUnixFont.c doesn't free tkFontPtr... */
 }
 
@@ -385,8 +394,8 @@ TkpDeleteFont(tkFontPtr)
  *
  * TkpGetFontFamilies --
  *
- *	Return information about the font families that are available
- *	on the display of the given window.
+ *	Return information about the font families that are available on the
+ *	display of the given window.
  *
  * Results:
  *	Modifies interp's result object to hold a list of all the available
@@ -396,9 +405,9 @@ TkpDeleteFont(tkFontPtr)
  */
 
 void
-TkpGetFontFamilies(interp, tkwin)
-    Tcl_Interp *interp;		/* Interp to hold result. */
-    Tk_Window tkwin;		/* For display to query. */
+TkpGetFontFamilies(
+    Tcl_Interp *interp,		/* Interp to hold result. */
+    Tk_Window tkwin)		/* For display to query. */
 {
     Tcl_Obj *resultPtr, *strPtr;
     XftFontSet *list;
@@ -425,6 +434,7 @@ TkpGetFontFamilies(interp, tkwin)
  *-------------------------------------------------------------------------
  *
  * TkpGetSubFonts --
+ *
  *	Called by [testfont subfonts] in the Tk testing package.
  *
  * Results:
@@ -434,9 +444,9 @@ TkpGetFontFamilies(interp, tkwin)
  */
 
 void
-TkpGetSubFonts(interp, tkfont)
-    Tcl_Interp *interp;
-    Tk_Font tkfont;
+TkpGetSubFonts(
+    Tcl_Interp *interp,
+    Tk_Font tkfont)
 {
     Tcl_Obj *objv[3], *listPtr, *resultPtr;
     UnixFtFont *fontPtr = (UnixFtFont *) tkfont;
@@ -472,26 +482,26 @@ TkpGetSubFonts(interp, tkfont)
 }
 
 int
-Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
-    Tk_Font tkfont;		/* Font in which characters will be drawn. */
-    CONST char *source;		/* UTF-8 string to be displayed.  Need not be
+Tk_MeasureChars(
+    Tk_Font tkfont,		/* Font in which characters will be drawn. */
+    CONST char *source,		/* UTF-8 string to be displayed. Need not be
 				 * '\0' terminated. */
-    int numBytes;		/* Maximum number of bytes to consider
-				 * from source string. */
-    int maxLength;		/* If >= 0, maxLength specifies the longest
+    int numBytes,		/* Maximum number of bytes to consider from
+				 * source string. */
+    int maxLength,		/* If >= 0, maxLength specifies the longest
 				 * permissible line length in pixels; don't
 				 * consider any character that would cross
-				 * this x-position.  If < 0, then line length
+				 * this x-position. If < 0, then line length
 				 * is unbounded and the flags argument is
 				 * ignored. */
-    int flags;			/* Various flag bits OR-ed together:
+    int flags,			/* Various flag bits OR-ed together:
 				 * TK_PARTIAL_OK means include the last char
 				 * which only partially fit on this line.
 				 * TK_WHOLE_WORDS means stop on a word
-				 * boundary, if possible.
-				 * TK_AT_LEAST_ONE means return at least one
-				 * character even if no characters fit. */
-    int *lengthPtr;		/* Filled with x-location just after the
+				 * boundary, if possible. TK_AT_LEAST_ONE
+				 * means return at least one character even if
+				 * no characters fit. */
+    int *lengthPtr)		/* Filled with x-location just after the
 				 * terminating character. */
 {
     UnixFtFont *fontPtr = (UnixFtFont *) tkfont;
@@ -502,11 +512,11 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
     int curX, newX;
     int termByte = 0, termX = 0;
     int curByte, newByte, sawNonSpace;
-#if 0
+#if DEBUG_FONTSEL
     char string[256];
     int len = 0;
-#endif
-    
+#endif /* DEBUG_FONTSEL */
+
     curX = 0;
     curByte = 0;
     sawNonSpace = 0;
@@ -517,7 +527,10 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 	c = (FcChar32)unichar;
 
 	if (clen <= 0) {
-	    /* This can't happen (but see #1185640) */
+	    /*
+	     * This can't happen (but see #1185640)
+	     */
+
 	    *lengthPtr = curX;
 	    return curByte;
 	}
@@ -534,9 +547,9 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 	    sawNonSpace = 1;
 	}
 
-#if 0
+#if DEBUG_FONTSEL
 	string[len++] = (char) c;
-#endif
+#endif /* DEBUG_FONTSEL */
 	ftFont = GetFont(fontPtr, c);
 
 	XftTextExtents32(fontPtr->display, ftFont, &c, 1, &extents);
@@ -558,10 +571,10 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 	curX = newX;
 	curByte = newByte;
     }
-#if 0
+#if DEBUG_FONTSEL
     string[len] = '\0';
     printf("MeasureChars %s length %d bytes %d\n", string, curX, curByte);
-#endif
+#endif /* DEBUG_FONTSEL */
     *lengthPtr = curX;
     return curByte;
 }
@@ -569,21 +582,21 @@ Tk_MeasureChars(tkfont, source, numBytes, maxLength, flags, lengthPtr)
 #define NUM_SPEC    1024
 
 void
-Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
-    Display *display;		/* Display on which to draw. */
-    Drawable drawable;		/* Window or pixmap in which to draw. */
-    GC gc;			/* Graphics context for drawing characters. */
-    Tk_Font tkfont;		/* Font in which characters will be drawn;
+Tk_DrawChars(
+    Display *display,		/* Display on which to draw. */
+    Drawable drawable,		/* Window or pixmap in which to draw. */
+    GC gc,			/* Graphics context for drawing characters. */
+    Tk_Font tkfont,		/* Font in which characters will be drawn;
 				 * must be the same as font used in GC. */
-    CONST char *source;		/* UTF-8 string to be displayed.  Need not be
-				 * '\0' terminated.  All Tk meta-characters
+    CONST char *source,		/* UTF-8 string to be displayed. Need not be
+				 * '\0' terminated. All Tk meta-characters
 				 * (tabs, control characters, and newlines)
 				 * should be stripped out of the string that
-				 * is passed to this function.  If they are
-				 * not stripped out, they will be displayed as
+				 * is passed to this function. If they are not
+				 * stripped out, they will be displayed as
 				 * regular printing characters. */
-    int numBytes;		/* Number of bytes in string. */
-    int x, y;			/* Coordinates at which to place origin of
+    int numBytes,		/* Number of bytes in string. */
+    int x, int y)		/* Coordinates at which to place origin of
 				 * string when drawing. */
 {
     const int maxCoord = 0x7FFF;	/* Xft coordinates are 16 bit values */
@@ -596,9 +609,9 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
     XGlyphInfo metrics;
 
     if (fontPtr->ftDraw == 0) {
-#if 0
+#if DEBUG_FONTSEL
 	printf("Switch to drawable 0x%x\n", drawable);
-#endif
+#endif /* DEBUG_FONTSEL */
 	fontPtr->ftDraw = XftDrawCreate(display, drawable,
 		DefaultVisual(display, fontPtr->screen),
 		DefaultColormap(display, fontPtr->screen));
@@ -607,7 +620,7 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
 	Tk_ErrorHandler handler;
 
         handler = Tk_CreateErrorHandler(display, -1, -1, -1,
-		(Tk_ErrorProc *) NULL, (ClientData) NULL);
+		NULL, (ClientData) NULL);
 	XftDrawChange(fontPtr->ftDraw, drawable);
 	fontPtr->drawable = drawable;
 	Tk_DeleteErrorHandler(handler);
@@ -627,10 +640,13 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
     while (numBytes > 0 && x <= maxCoord && y <= maxCoord) {
 	XftFont *ftFont;
 	FcChar32 c;
-	
+
 	clen = FcUtf8ToUcs4((FcChar8 *) source, &c, numBytes);
 	if (clen <= 0) {
-	    /* This should not happen, but it can. */
+	    /*
+	     * This should not happen, but it can.
+	     */
+
 	    return;
 	}
 	source += clen;
@@ -658,3 +674,11 @@ Tk_DrawChars(display, drawable, gc, tkfont, source, numBytes, x, y)
 	XftDrawGlyphFontSpec(fontPtr->ftDraw, &fontPtr->color, specs, nspec);
     }
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/unix/tkUnixScale.c b/unix/tkUnixScale.c
index 716a496..1d5254d 100644
--- a/unix/tkUnixScale.c
+++ b/unix/tkUnixScale.c
@@ -1,33 +1,32 @@
-/* 
+/*
  * tkUnixScale.c --
  *
- *	This file implements the X specific portion of the scrollbar
- *	widget.
+ *	This file implements the X specific portion of the scrollbar widget.
  *
  * Copyright (c) 1996 by Sun Microsystems, Inc.
  * Copyright (c) 1998-2000 by Scriptics Corporation.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixScale.c,v 1.9 2004/10/28 15:06:27 patthoyts Exp $
+ * RCS: @(#) $Id: tkUnixScale.c,v 1.10 2005/11/14 11:54:21 dkf Exp $
  */
 
 #include "tkScale.h"
 #include "tkInt.h"
 
 /*
- * Forward declarations for procedures defined later in this file:
+ * Forward declarations for functions defined later in this file:
  */
 
-static void		DisplayHorizontalScale _ANSI_ARGS_((TkScale *scalePtr,
-			    Drawable drawable, XRectangle *drawnAreaPtr));
-static void		DisplayHorizontalValue _ANSI_ARGS_((TkScale *scalePtr,
-			    Drawable drawable, double value, int top));
-static void		DisplayVerticalScale _ANSI_ARGS_((TkScale *scalePtr,
-			    Drawable drawable, XRectangle *drawnAreaPtr));
-static void		DisplayVerticalValue _ANSI_ARGS_((TkScale *scalePtr,
-			    Drawable drawable, double value, int rightEdge));
+static void		DisplayHorizontalScale(TkScale *scalePtr,
+			    Drawable drawable, XRectangle *drawnAreaPtr);
+static void		DisplayHorizontalValue(TkScale *scalePtr,
+			    Drawable drawable, double value, int top);
+static void		DisplayVerticalScale(TkScale *scalePtr,
+			    Drawable drawable, XRectangle *drawnAreaPtr);
+static void		DisplayVerticalValue(TkScale *scalePtr,
+			    Drawable drawable, double value, int rightEdge);
 
 /*
  *----------------------------------------------------------------------
@@ -46,8 +45,8 @@ static void		DisplayVerticalValue _ANSI_ARGS_((TkScale *scalePtr,
  */
 
 TkScale *
-TkpCreateScale(tkwin)
-    Tk_Window tkwin;
+TkpCreateScale(
+    Tk_Window tkwin)
 {
     return (TkScale *) ckalloc(sizeof(TkScale));
 }
@@ -57,9 +56,9 @@ TkpCreateScale(tkwin)
  *
  * TkpDestroyScale --
  *
- *	Destroy a TkScale structure.  It's necessary to do this with
- *	Tcl_EventuallyFree to allow the Tcl_Preserve(scalePtr) to work
- *	as expected in TkpDisplayScale. (hobbs)
+ *	Destroy a TkScale structure. It's necessary to do this with
+ *	Tcl_EventuallyFree to allow the Tcl_Preserve(scalePtr) to work as
+ *	expected in TkpDisplayScale. (hobbs)
  *
  * Results:
  *	None
@@ -71,8 +70,8 @@ TkpCreateScale(tkwin)
  */
 
 void
-TkpDestroyScale(scalePtr)
-    TkScale *scalePtr;
+TkpDestroyScale(
+    TkScale *scalePtr)
 {
     Tcl_EventuallyFree((ClientData) scalePtr, TCL_DYNAMIC);
 }
@@ -82,14 +81,14 @@ TkpDestroyScale(scalePtr)
  *
  * DisplayVerticalScale --
  *
- *	This procedure redraws the contents of a vertical scale
- *	window.  It is invoked as a do-when-idle handler, so it only
- *	runs when there's nothing else for the application to do.
+ *	This function redraws the contents of a vertical scale window. It is
+ *	invoked as a do-when-idle handler, so it only runs when there's
+ *	nothing else for the application to do.
  *
  * Results:
- *	There is no return value.  If only a part of the scale needs
- *	to be redrawn, then drawnAreaPtr is modified to reflect the
- *	area that was actually modified.
+ *	There is no return value. If only a part of the scale needs to be
+ *	redrawn, then drawnAreaPtr is modified to reflect the area that was
+ *	actually modified.
  *
  * Side effects:
  *	Information appears on the screen.
@@ -98,15 +97,14 @@ TkpDestroyScale(scalePtr)
  */
 
 static void
-DisplayVerticalScale(scalePtr, drawable, drawnAreaPtr)
-    TkScale *scalePtr;			/* Widget record for scale. */
-    Drawable drawable;			/* Where to display scale (window
-					 * or pixmap). */
-    XRectangle *drawnAreaPtr;		/* Initally contains area of window;
-					 * if only a part of the scale is
-					 * redrawn, gets modified to reflect
-					 * the part of the window that was
-					 * redrawn. */
+DisplayVerticalScale(
+    TkScale *scalePtr,		/* Widget record for scale. */
+    Drawable drawable,		/* Where to display scale (window or
+				 * pixmap). */
+    XRectangle *drawnAreaPtr)	/* Initally contains area of window; if only a
+				 * part of the scale is redrawn, gets modified
+				 * to reflect the part of the window that was
+				 * redrawn. */
 {
     Tk_Window tkwin = scalePtr->tkwin;
     int x, y, width, height, shadowWidth;
@@ -136,18 +134,19 @@ DisplayVerticalScale(scalePtr, drawable, drawnAreaPtr)
 	    double ticks, maxTicks;
 
 	    /*
-	     * Ensure that we will only draw enough of the tick values
-	     * such that they don't overlap
+	     * Ensure that we will only draw enough of the tick values such
+	     * that they don't overlap
 	     */
+
 	    ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
 		    / tickInterval);
 	    maxTicks = (double) Tk_Height(tkwin)
-		/ (double) scalePtr->fontHeight;
+		    / (double) scalePtr->fontHeight;
 	    if (ticks > maxTicks) {
 		tickInterval *= (ticks / maxTicks);
 	    }
 	    for (tickValue = scalePtr->fromValue; ;
-		 tickValue += tickInterval) {
+		    tickValue += tickInterval) {
 		/*
 		 * The TkRoundToResolution call gets rid of accumulated
 		 * round-off errors, if any.
@@ -226,7 +225,7 @@ DisplayVerticalScale(scalePtr, drawable, drawnAreaPtr)
 
 	Tk_GetFontMetrics(scalePtr->tkfont, &fm);
 	Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
-		scalePtr->tkfont, scalePtr->label, 
+		scalePtr->tkfont, scalePtr->label,
                 scalePtr->labelLength, scalePtr->vertLabelX,
                 scalePtr->inset + (3*fm.ascent)/2);
     }
@@ -237,30 +236,30 @@ DisplayVerticalScale(scalePtr, drawable, drawnAreaPtr)
  *
  * DisplayVerticalValue --
  *
- *	This procedure is called to display values (scale readings)
- *	for vertically-oriented scales.
+ *	This function is called to display values (scale readings) for
+ *	vertically-oriented scales.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The numerical value corresponding to value is displayed with
- *	its right edge at "rightEdge", and at a vertical position in
- *	the scale that corresponds to "value".
+ *	The numerical value corresponding to value is displayed with its right
+ *	edge at "rightEdge", and at a vertical position in the scale that
+ *	corresponds to "value".
  *
  *----------------------------------------------------------------------
  */
 
 static void
-DisplayVerticalValue(scalePtr, drawable, value, rightEdge)
-    register TkScale *scalePtr;	/* Information about widget in which to
+DisplayVerticalValue(
+    register TkScale *scalePtr,	/* Information about widget in which to
 				 * display value. */
-    Drawable drawable;		/* Pixmap or window in which to draw
-				 * the value. */
-    double value;		/* Y-coordinate of number to display,
-				 * specified in application coords, not
-				 * in pixels (we'll compute pixels). */
-    int rightEdge;		/* X-coordinate of right edge of text,
+    Drawable drawable,		/* Pixmap or window in which to draw the
+				 * value. */
+    double value,		/* Y-coordinate of number to display,
+				 * specified in application coords, not in
+				 * pixels (we'll compute pixels). */
+    int rightEdge)		/* X-coordinate of right edge of text,
 				 * specified in pixels. */
 {
     register Tk_Window tkwin = scalePtr->tkwin;
@@ -275,8 +274,8 @@ DisplayVerticalValue(scalePtr, drawable, value, rightEdge)
     width = Tk_TextWidth(scalePtr->tkfont, valueString, length);
 
     /*
-     * Adjust the y-coordinate if necessary to keep the text entirely
-     * inside the window.
+     * Adjust the y-coordinate if necessary to keep the text entirely inside
+     * the window.
      */
 
     if ((y - fm.ascent) < (scalePtr->inset + SPACING)) {
@@ -294,14 +293,14 @@ DisplayVerticalValue(scalePtr, drawable, value, rightEdge)
  *
  * DisplayHorizontalScale --
  *
- *	This procedure redraws the contents of a horizontal scale
- *	window.  It is invoked as a do-when-idle handler, so it only
- *	runs when there's nothing else for the application to do.
+ *	This function redraws the contents of a horizontal scale window. It is
+ *	invoked as a do-when-idle handler, so it only runs when there's
+ *	nothing else for the application to do.
  *
  * Results:
- *	There is no return value.  If only a part of the scale needs
- *	to be redrawn, then drawnAreaPtr is modified to reflect the
- *	area that was actually modified.
+ *	There is no return value. If only a part of the scale needs to be
+ *	redrawn, then drawnAreaPtr is modified to reflect the area that was
+ *	actually modified.
  *
  * Side effects:
  *	Information appears on the screen.
@@ -310,15 +309,14 @@ DisplayVerticalValue(scalePtr, drawable, value, rightEdge)
  */
 
 static void
-DisplayHorizontalScale(scalePtr, drawable, drawnAreaPtr)
-    TkScale *scalePtr;			/* Widget record for scale. */
-    Drawable drawable;			/* Where to display scale (window
-					 * or pixmap). */
-    XRectangle *drawnAreaPtr;		/* Initally contains area of window;
-					 * if only a part of the scale is
-					 * redrawn, gets modified to reflect
-					 * the part of the window that was
-					 * redrawn. */
+DisplayHorizontalScale(
+    TkScale *scalePtr,		/* Widget record for scale. */
+    Drawable drawable,		/* Where to display scale (window or
+				 * pixmap). */
+    XRectangle *drawnAreaPtr)	/* Initally contains area of window; if only a
+				 * part of the scale is redrawn, gets modified
+				 * to reflect the part of the window that was
+				 * redrawn. */
 {
     register Tk_Window tkwin = scalePtr->tkwin;
     int x, y, width, height, shadowWidth;
@@ -349,15 +347,16 @@ DisplayHorizontalScale(scalePtr, drawable, drawnAreaPtr)
 	    double ticks, maxTicks;
 
 	    /*
-	     * Ensure that we will only draw enough of the tick values
-	     * such that they don't overlap.  We base this off the width that
-	     * fromValue would take.  Not exact, but better than no constraint.
+	     * Ensure that we will only draw enough of the tick values such
+	     * that they don't overlap. We base this off the width that
+	     * fromValue would take. Not exact, but better than no constraint.
 	     */
+
 	    ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
 		    / tickInterval);
 	    sprintf(valueString, scalePtr->format, scalePtr->fromValue);
 	    maxTicks = (double) Tk_Width(tkwin)
-		/ (double) Tk_TextWidth(scalePtr->tkfont, valueString, -1);
+		    / (double) Tk_TextWidth(scalePtr->tkfont, valueString, -1);
 	    if (ticks > maxTicks) {
 		tickInterval *= (ticks / maxTicks);
 	    }
@@ -442,8 +441,8 @@ DisplayHorizontalScale(scalePtr, drawable, drawnAreaPtr)
 
 	Tk_GetFontMetrics(scalePtr->tkfont, &fm);
 	Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
-		scalePtr->tkfont, scalePtr->label, 
-                scalePtr->labelLength, scalePtr->inset + fm.ascent/2, 
+		scalePtr->tkfont, scalePtr->label,
+                scalePtr->labelLength, scalePtr->inset + fm.ascent/2,
                 scalePtr->horizLabelY + fm.ascent);
     }
 }
@@ -453,31 +452,31 @@ DisplayHorizontalScale(scalePtr, drawable, drawnAreaPtr)
  *
  * DisplayHorizontalValue --
  *
- *	This procedure is called to display values (scale readings)
- *	for horizontally-oriented scales.
+ *	This function is called to display values (scale readings) for
+ *	horizontally-oriented scales.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The numerical value corresponding to value is displayed with
- *	its bottom edge at "bottom", and at a horizontal position in
- *	the scale that corresponds to "value".
+ *	The numerical value corresponding to value is displayed with its
+ *	bottom edge at "bottom", and at a horizontal position in the scale
+ *	that corresponds to "value".
  *
  *----------------------------------------------------------------------
  */
 
 static void
-DisplayHorizontalValue(scalePtr, drawable, value, top)
-    register TkScale *scalePtr;	/* Information about widget in which to
+DisplayHorizontalValue(
+    register TkScale *scalePtr,	/* Information about widget in which to
 				 * display value. */
-    Drawable drawable;		/* Pixmap or window in which to draw
-				 * the value. */
-    double value;		/* X-coordinate of number to display,
-				 * specified in application coords, not
-				 * in pixels (we'll compute pixels). */
-    int top;			/* Y-coordinate of top edge of text,
-				 * specified in pixels. */
+    Drawable drawable,		/* Pixmap or window in which to draw the
+				 * value. */
+    double value,		/* X-coordinate of number to display,
+				 * specified in application coords, not in
+				 * pixels (we'll compute pixels). */
+    int top)			/* Y-coordinate of top edge of text, specified
+				 * in pixels. */
 {
     register Tk_Window tkwin = scalePtr->tkwin;
     int x, y, length, width;
@@ -492,18 +491,19 @@ DisplayHorizontalValue(scalePtr, drawable, value, top)
     width = Tk_TextWidth(scalePtr->tkfont, valueString, length);
 
     /*
-     * Adjust the x-coordinate if necessary to keep the text entirely
-     * inside the window.
+     * Adjust the x-coordinate if necessary to keep the text entirely inside
+     * the window.
      */
 
     x -= (width)/2;
     if (x < (scalePtr->inset + SPACING)) {
 	x = scalePtr->inset + SPACING;
     }
+
     /*
-     * Check the right border so use starting point +text width
-     * for the check.
+     * Check the right border so use starting point +text width for the check.
      */
+
     if (x + width >= (Tk_Width(tkwin) - scalePtr->inset)) {
 	x = Tk_Width(tkwin) - scalePtr->inset - SPACING - width;
     }
@@ -516,8 +516,8 @@ DisplayHorizontalValue(scalePtr, drawable, value, top)
  *
  * TkpDisplayScale --
  *
- *	This procedure is invoked as an idle handler to redisplay
- *	the contents of a scale widget.
+ *	This function is invoked as an idle handler to redisplay the contents
+ *	of a scale widget.
  *
  * Results:
  *	None.
@@ -529,8 +529,8 @@ DisplayHorizontalValue(scalePtr, drawable, value, top)
  */
 
 void
-TkpDisplayScale(clientData)
-    ClientData clientData;	/* Widget record for scale. */
+TkpDisplayScale(
+    ClientData clientData)	/* Widget record for scale. */
 {
     TkScale *scalePtr = (TkScale *) clientData;
     Tk_Window tkwin = scalePtr->tkwin;
@@ -548,6 +548,7 @@ TkpDisplayScale(clientData)
     /*
      * Invoke the scale's command if needed.
      */
+
     Tcl_Preserve((ClientData) scalePtr);
     if ((scalePtr->flags & INVOKE_COMMAND) && (scalePtr->command != NULL)) {
 	Tcl_Preserve((ClientData) interp);
@@ -568,10 +569,10 @@ TkpDisplayScale(clientData)
     Tcl_Release((ClientData) scalePtr);
 
     /*
-     * In order to avoid screen flashes, this procedure redraws
-     * the scale in a pixmap, then copies the pixmap to the
-     * screen in a single operation.  This means that there's no
-     * point in time where the on-sreen image has been cleared.
+     * In order to avoid screen flashes, this function redraws the scale in a
+     * pixmap, then copies the pixmap to the screen in a single operation.
+     * This means that there's no point in time where the on-sreen image has
+     * been cleared.
      */
 
     pixmap = Tk_GetPixmap(scalePtr->display, Tk_WindowId(tkwin),
@@ -582,9 +583,8 @@ TkpDisplayScale(clientData)
     drawnArea.height = Tk_Height(tkwin);
 
     /*
-     * Much of the redisplay is done totally differently for
-     * horizontal and vertical scales.  Handle the part that's
-     * different.
+     * Much of the redisplay is done totally differently for horizontal and
+     * vertical scales. Handle the part that's different.
      */
 
     if (scalePtr->orient == ORIENT_VERTICAL) {
@@ -594,9 +594,8 @@ TkpDisplayScale(clientData)
     }
 
     /*
-     * Now handle the part of redisplay that is the same for
-     * horizontal and vertical scales:  border and traversal
-     * highlight.
+     * Now handle the part of redisplay that is the same for horizontal and
+     * vertical scales: border and traversal highlight.
      */
 
     if (scalePtr->flags & REDRAW_OTHER) {
@@ -609,7 +608,7 @@ TkpDisplayScale(clientData)
 	}
 	if (scalePtr->highlightWidth != 0) {
 	    GC gc;
-    
+
 	    if (scalePtr->flags & GOT_FOCUS) {
 		gc = Tk_GCForColor(scalePtr->highlightColorPtr, pixmap);
 	    } else {
@@ -621,8 +620,8 @@ TkpDisplayScale(clientData)
     }
 
     /*
-     * Copy the information from the off-screen pixmap onto the screen,
-     * then delete the pixmap.
+     * Copy the information from the off-screen pixmap onto the screen, then
+     * delete the pixmap.
      */
 
     XCopyArea(scalePtr->display, pixmap, Tk_WindowId(tkwin),
@@ -630,7 +629,7 @@ TkpDisplayScale(clientData)
 	    drawnArea.height, drawnArea.x, drawnArea.y);
     Tk_FreePixmap(scalePtr->display, pixmap);
 
-    done:
+  done:
     scalePtr->flags &= ~REDRAW_ALL;
 }
 
@@ -639,13 +638,12 @@ TkpDisplayScale(clientData)
  *
  * TkpScaleElement --
  *
- *	Determine which part of a scale widget lies under a given
- *	point.
+ *	Determine which part of a scale widget lies under a given point.
  *
  * Results:
- *	The return value is either TROUGH1, SLIDER, TROUGH2, or
- *	OTHER, depending on which of the scale's active elements
- *	(if any) is under the point at (x,y).
+ *	The return value is either TROUGH1, SLIDER, TROUGH2, or OTHER,
+ *	depending on which of the scale's active elements (if any) is under
+ *	the point at (x,y).
  *
  * Side effects:
  *	None.
@@ -654,9 +652,9 @@ TkpDisplayScale(clientData)
  */
 
 int
-TkpScaleElement(scalePtr, x, y)
-    TkScale *scalePtr;		/* Widget record for scale. */
-    int x, y;			/* Coordinates within scalePtr's window. */
+TkpScaleElement(
+    TkScale *scalePtr,		/* Widget record for scale. */
+    int x, int y)		/* Coordinates within scalePtr's window. */
 {
     int sliderFirst;
 
@@ -700,3 +698,11 @@ TkpScaleElement(scalePtr, x, y)
     }
     return TROUGH2;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */