1 files changed, 176 insertions, 178 deletions

diff --git a/win/tkWin3d.c b/win/tkWin3d.c
index 3c97560..8d1002b 100644
--- a/win/tkWin3d.c
+++ b/win/tkWin3d.c
@@ -1,31 +1,30 @@
-/* 
+/*
  * tkWin3d.c --
  *
- *	This file contains the platform specific routines for
- *	drawing 3d borders in the Windows 95 style.
+ *	This file contains the platform specific routines for drawing 3D
+ *	borders in the Windows 95 style.
  *
  * Copyright (c) 1996 by Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkWin3d.c,v 1.7 2004/01/13 02:06:01 davygrvy Exp $
+ * RCS: @(#) $Id: tkWin3d.c,v 1.8 2005/12/02 00:19:04 dkf Exp $
  */
 
 #include "tkWinInt.h"
 #include "tk3d.h"
 
 /*
- * This structure is used to keep track of the extra colors used by
- * Windows 3d borders.
+ * This structure is used to keep track of the extra colors used by Windows 3D
+ * borders.
  */
 
 typedef struct {
     TkBorder info;
-    XColor *light2ColorPtr; /* System3dLight */
-    XColor *dark2ColorPtr;  /* System3dDarkShadow */
+    XColor *light2ColorPtr;	/* System3dLight */
+    XColor *dark2ColorPtr;	/* System3dDarkShadow */
 } WinBorder;
-
 
 /*
  *----------------------------------------------------------------------
@@ -44,9 +43,10 @@ typedef struct {
  */
 
 TkBorder *
-TkpGetBorder()
+TkpGetBorder(void)
 {
     WinBorder *borderPtr = (WinBorder *) ckalloc(sizeof(WinBorder));
+
     borderPtr->light2ColorPtr = NULL;
     borderPtr->dark2ColorPtr = NULL;
     return (TkBorder *) borderPtr;
@@ -57,8 +57,8 @@ TkpGetBorder()
  *
  * TkpFreeBorder --
  *
- *	This function frees any colors allocated by the platform
- *	specific part of this module.
+ *	This function frees any colors allocated by the platform specific part
+ *	of this module.
  *
  * Results:
  *	None.
@@ -70,8 +70,8 @@ TkpGetBorder()
  */
 
 void
-TkpFreeBorder(borderPtr)
-    TkBorder *borderPtr;
+TkpFreeBorder(
+    TkBorder *borderPtr)
 {
     WinBorder *winBorderPtr = (WinBorder *) borderPtr;
     if (winBorderPtr->light2ColorPtr) {
@@ -87,18 +87,17 @@ TkpFreeBorder(borderPtr)
  *
  * Tk_3DVerticalBevel --
  *
- *	This procedure draws a vertical bevel along one side of
- *	an object.  The bevel is always rectangular in shape:
+ *	This procedure draws a vertical bevel along one side of an object. The
+ *	bevel is always rectangular in shape:
  *			|||
  *			|||
  *			|||
  *			|||
  *			|||
  *			|||
- *	An appropriate shadow color is chosen for the bevel based
- *	on the leftBevel and relief arguments.  Normally this
- *	procedure is called first, then Tk_3DHorizontalBevel is
- *	called next to draw neat corners.
+ *	An appropriate shadow color is chosen for the bevel based on the
+ *	leftBevel and relief arguments. Normally this procedure is called
+ *	first, then Tk_3DHorizontalBevel is called next to draw neat corners.
  *
  * Results:
  *	None.
@@ -110,19 +109,18 @@ TkpFreeBorder(borderPtr)
  */
 
 void
-Tk_3DVerticalBevel(tkwin, drawable, border, x, y, width, height,
-	leftBevel, relief)
-    Tk_Window tkwin;		/* Window for which border was allocated. */
-    Drawable drawable;		/* X window or pixmap in which to draw. */
-    Tk_3DBorder border;		/* Token for border to draw. */
-    int x, y, width, height;	/* Area of vertical bevel. */
-    int leftBevel;		/* Non-zero means this bevel forms the
-				 * left side of the object;  0 means it
-				 * forms the right side. */
-    int relief;			/* Kind of bevel to draw.  For example,
-				 * TK_RELIEF_RAISED means interior of
-				 * object should appear higher than
-				 * exterior. */
+Tk_3DVerticalBevel(
+    Tk_Window tkwin,		/* Window for which border was allocated. */
+    Drawable drawable,		/* X window or pixmap in which to draw. */
+    Tk_3DBorder border,		/* Token for border to draw. */
+    int x, int y, int width, int height,
+				/* Area of vertical bevel. */
+    int leftBevel,		/* Non-zero means this bevel forms the left
+				 * side of the object; 0 means it forms the
+				 * right side. */
+    int relief)			/* Kind of bevel to draw. For example,
+				 * TK_RELIEF_RAISED means interior of object
+				 * should appear higher than exterior. */
 {
     TkBorder *borderPtr = (TkBorder *) border;
     int left, right;
@@ -136,36 +134,36 @@ Tk_3DVerticalBevel(tkwin, drawable, border, x, y, width, height,
     }
 
     switch (relief) {
-	case TK_RELIEF_RAISED:
-	    left = (leftBevel)
+    case TK_RELIEF_RAISED:
+	left = (leftBevel)
 		? borderPtr->lightGC->foreground
 		: borderPtr->darkGC->foreground;
-	    right = (leftBevel)
+	right = (leftBevel)
 		? ((WinBorder *)borderPtr)->light2ColorPtr->pixel
 		: ((WinBorder *)borderPtr)->dark2ColorPtr->pixel;
-	    break;
-	case TK_RELIEF_SUNKEN:
-	    left = (leftBevel)
+	break;
+    case TK_RELIEF_SUNKEN:
+	left = (leftBevel)
 		? borderPtr->darkGC->foreground
 		: ((WinBorder *)borderPtr)->light2ColorPtr->pixel;
-	    right = (leftBevel)
+	right = (leftBevel)
 		? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel
 		: borderPtr->lightGC->foreground;
-	    break;
-	case TK_RELIEF_RIDGE:
-	    left = borderPtr->lightGC->foreground;
-	    right = borderPtr->darkGC->foreground;
-	    break;
-	case TK_RELIEF_GROOVE:
-	    left = borderPtr->darkGC->foreground;
-	    right = borderPtr->lightGC->foreground;
-	    break;
-	case TK_RELIEF_FLAT:
-	    left = right = borderPtr->bgGC->foreground;
-	    break;
-	case TK_RELIEF_SOLID:
-	    left = right = RGB(0,0,0);
-	    break;
+	break;
+    case TK_RELIEF_RIDGE:
+	left = borderPtr->lightGC->foreground;
+	right = borderPtr->darkGC->foreground;
+	break;
+    case TK_RELIEF_GROOVE:
+	left = borderPtr->darkGC->foreground;
+	right = borderPtr->lightGC->foreground;
+	break;
+    case TK_RELIEF_FLAT:
+	left = right = borderPtr->bgGC->foreground;
+	break;
+    case TK_RELIEF_SOLID:
+	left = right = RGB(0,0,0);
+	break;
     }
     half = width/2;
     if (leftBevel && (width & 1)) {
@@ -181,9 +179,9 @@ Tk_3DVerticalBevel(tkwin, drawable, border, x, y, width, height,
  *
  * Tk_3DHorizontalBevel --
  *
- *	This procedure draws a horizontal bevel along one side of
- *	an object.  The bevel has mitered corners (depending on
- *	leftIn and rightIn arguments).
+ *	This procedure draws a horizontal bevel along one side of an object.
+ *	The bevel has mitered corners (depending on leftIn and rightIn
+ *	arguments).
  *
  * Results:
  *	None.
@@ -195,30 +193,28 @@ Tk_3DVerticalBevel(tkwin, drawable, border, x, y, width, height,
  */
 
 void
-Tk_3DHorizontalBevel(tkwin, drawable, border, x, y, width, height,
-	leftIn, rightIn, topBevel, relief)
-    Tk_Window tkwin;		/* Window for which border was allocated. */
-    Drawable drawable;		/* X window or pixmap in which to draw. */
-    Tk_3DBorder border;		/* Token for border to draw. */
-    int x, y, width, height;	/* Bounding box of area of bevel.  Height
-				 * gives width of border. */
-    int leftIn, rightIn;	/* Describes whether the left and right
-				 * edges of the bevel angle in or out as
-				 * they go down.  For example, if "leftIn"
-				 * is true, the left side of the bevel
-				 * looks like this:
+Tk_3DHorizontalBevel(
+    Tk_Window tkwin,		/* Window for which border was allocated. */
+    Drawable drawable,		/* X window or pixmap in which to draw. */
+    Tk_3DBorder border,		/* Token for border to draw. */
+    int x, int y, int width, int height,
+				/* Bounding box of area of bevel. Height gives
+				 * width of border. */
+    int leftIn, int rightIn,	/* Describes whether the left and right edges
+				 * of the bevel angle in or out as they go
+				 * down. For example, if "leftIn" is true, the
+				 * left side of the bevel looks like this:
 				 *	___________
 				 *	 __________
 				 *	  _________
 				 *	   ________
 				 */
-    int topBevel;		/* Non-zero means this bevel forms the
-				 * top side of the object;  0 means it
-				 * forms the bottom side. */
-    int relief;			/* Kind of bevel to draw.  For example,
-				 * TK_RELIEF_RAISED means interior of
-				 * object should appear higher than
-				 * exterior. */
+    int topBevel,		/* Non-zero means this bevel forms the top
+				 * side of the object; 0 means it forms the
+				 * bottom side. */
+    int relief)			/* Kind of bevel to draw. For example,
+				 * TK_RELIEF_RAISED means interior of object
+				 * should appear higher than exterior. */
 {
     TkBorder *borderPtr = (TkBorder *) border;
     Display *display = Tk_Display(tkwin);
@@ -232,40 +228,40 @@ Tk_3DHorizontalBevel(tkwin, drawable, border, x, y, width, height,
     }
 
     /*
-     * Compute a GC for the top half of the bevel and a GC for the
-     * bottom half (they're the same in many cases).
+     * Compute a GC for the top half of the bevel and a GC for the bottom half
+     * (they're the same in many cases).
      */
 
     switch (relief) {
-	case TK_RELIEF_RAISED:
-	    topColor = (topBevel)
+    case TK_RELIEF_RAISED:
+	topColor = (topBevel)
 		? borderPtr->lightGC->foreground
 		: borderPtr->darkGC->foreground;
-	    bottomColor = (topBevel)
+	bottomColor = (topBevel)
 		? ((WinBorder *)borderPtr)->light2ColorPtr->pixel
 		: ((WinBorder *)borderPtr)->dark2ColorPtr->pixel;
-	    break;
-	case TK_RELIEF_SUNKEN:
-	    topColor = (topBevel)
+	break;
+    case TK_RELIEF_SUNKEN:
+	topColor = (topBevel)
 		? borderPtr->darkGC->foreground
 		: ((WinBorder *)borderPtr)->light2ColorPtr->pixel;
-	    bottomColor = (topBevel)
+	bottomColor = (topBevel)
 		? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel
 		: borderPtr->lightGC->foreground;
-	    break;
-	case TK_RELIEF_RIDGE:
-	    topColor = borderPtr->lightGC->foreground;
-	    bottomColor = borderPtr->darkGC->foreground;
-	    break;
-	case TK_RELIEF_GROOVE:
-	    topColor = borderPtr->darkGC->foreground;
-	    bottomColor = borderPtr->lightGC->foreground;
-	    break;
-	case TK_RELIEF_FLAT:
-	    topColor = bottomColor = borderPtr->bgGC->foreground;
-	    break;
-	case TK_RELIEF_SOLID:
-	    topColor = bottomColor = RGB(0,0,0);
+	break;
+    case TK_RELIEF_RIDGE:
+	topColor = borderPtr->lightGC->foreground;
+	bottomColor = borderPtr->darkGC->foreground;
+	break;
+    case TK_RELIEF_GROOVE:
+	topColor = borderPtr->darkGC->foreground;
+	bottomColor = borderPtr->lightGC->foreground;
+	break;
+    case TK_RELIEF_FLAT:
+	topColor = bottomColor = borderPtr->bgGC->foreground;
+	break;
+    case TK_RELIEF_SOLID:
+	topColor = bottomColor = RGB(0,0,0);
     }
 
     /*
@@ -298,8 +294,7 @@ Tk_3DHorizontalBevel(tkwin, drawable, border, x, y, width, height,
     for ( ; y < bottom; y++) {
 	/*
 	 * In some weird cases (such as large border widths for skinny
-	 * rectangles) x1 can be >= x2.  Don't draw the lines
-	 * in these cases.
+	 * rectangles) x1 can be >= x2. Don't draw the lines in these cases.
 	 */
 
 	if (x1 < x2) {
@@ -317,27 +312,26 @@ Tk_3DHorizontalBevel(tkwin, drawable, border, x, y, width, height,
  *
  * TkpGetShadows --
  *
- *	This procedure computes the shadow colors for a 3-D border
- *	and fills in the corresponding fields of the Border structure.
- *	It's called lazily, so that the colors aren't allocated until
- *	something is actually drawn with them.  That way, if a border
- *	is only used for flat backgrounds the shadow colors will
- *	never be allocated.
+ *	This procedure computes the shadow colors for a 3-D border and fills
+ *	in the corresponding fields of the Border structure. It's called
+ *	lazily, so that the colors aren't allocated until something is
+ *	actually drawn with them. That way, if a border is only used for flat
+ *	backgrounds the shadow colors will never be allocated.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The lightGC and darkGC fields in borderPtr get filled in,
- *	if they weren't already.
+ *	The lightGC and darkGC fields in borderPtr get filled in, if they
+ *	weren't already.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkpGetShadows(borderPtr, tkwin)
-    TkBorder *borderPtr;	/* Information about border. */
-    Tk_Window tkwin;		/* Window where border will be used for
+TkpGetShadows(
+    TkBorder *borderPtr,	/* Information about border. */
+    Tk_Window tkwin)		/* Window where border will be used for
 				 * drawing. */
 {
     XColor lightColor, darkColor;
@@ -354,13 +348,13 @@ TkpGetShadows(borderPtr, tkwin)
      */
 
     if ((TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_3DFACE)
-	|| (TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_WINDOW)) {
+	    || (TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_WINDOW)) {
 	borderPtr->darkColorPtr = Tk_GetColor(NULL, tkwin,
-	    Tk_GetUid("SystemButtonShadow"));
+		Tk_GetUid("SystemButtonShadow"));
 	gcValues.foreground = borderPtr->darkColorPtr->pixel;
 	borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
 	borderPtr->lightColorPtr = Tk_GetColor(NULL, tkwin,
-	    Tk_GetUid("SystemButtonHighlight"));
+		Tk_GetUid("SystemButtonHighlight"));
 	gcValues.foreground = borderPtr->lightColorPtr->pixel;
 	borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
 	((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColor(NULL, tkwin,
@@ -368,45 +362,42 @@ TkpGetShadows(borderPtr, tkwin)
 	((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColor(NULL, tkwin,
 		Tk_GetUid("System3dLight"));
 	return;
-    } else {
-	darkColor.red = 0;
-	darkColor.green = 0;
-	darkColor.blue = 0;
-	((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColorByValue(tkwin,
+    }
+    darkColor.red = 0;
+    darkColor.green = 0;
+    darkColor.blue = 0;
+    ((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColorByValue(tkwin,
 	    &darkColor);
-	lightColor = *(borderPtr->bgColorPtr);
-	((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColorByValue(tkwin, 
+    lightColor = *(borderPtr->bgColorPtr);
+    ((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColorByValue(tkwin,
 	    &lightColor);
-    }
-    
+
     /*
-     * First, handle the case of a color display with lots of colors.
-     * The shadow colors get computed using whichever formula results
-     * in the greatest change in color:
-     * 1. Lighter shadow is half-way to white, darker shadow is half
-     *    way to dark.
-     * 2. Lighter shadow is 40% brighter than background, darker shadow
-     *    is 40% darker than background.
+     * First, handle the case of a color display with lots of colors. The
+     * shadow colors get computed using whichever formula results in the
+     * greatest change in color:
+     * 1. Lighter shadow is half-way to white, darker shadow is half way to
+     *    dark.
+     * 2. Lighter shadow is 40% brighter than background, darker shadow is 40%
+     *    darker than background.
      */
 
     if (Tk_Depth(tkwin) >= 6) {
 	/*
-	 * This is a color display with lots of colors.  For the dark
-	 * shadow, cut 40% from each of the background color components.
-	 * But if the background is already very dark, make the
-	 * dark color a little lighter than the background by increasing
-	 * each color component 1/4th of the way to MAX_INTENSITY.
+	 * This is a color display with lots of colors. For the dark shadow,
+	 * cut 40% from each of the background color components. But if the
+	 * background is already very dark, make the dark color a little
+	 * lighter than the background by increasing each color component
+	 * 1/4th of the way to MAX_INTENSITY.
 	 *
-	 * For the light shadow, boost each component by 40% or half-way
-	 * to white, whichever is greater (the first approach works
-	 * better for unsaturated colors, the second for saturated ones).
-	 * But if the background is already very bright, instead choose a
-	 * slightly darker color for the light shadow by reducing each
-	 * color component by 10%.
+	 * For the light shadow, boost each component by 40% or half-way to
+	 * white, whichever is greater (the first approach works better for
+	 * unsaturated colors, the second for saturated ones). But if the
+	 * background is already very bright, instead choose a slightly darker
+	 * color for the light shadow by reducing each color component by 10%.
 	 *
-	 * Compute the colors using integers, not using lightColor.red
-	 * etc.: these are shorts and may have problems with integer
-	 * overflow.
+	 * Compute the colors using integers, not using lightColor.red etc.:
+	 * these are shorts and may have problems with integer overflow.
 	 */
 
 	/*
@@ -463,7 +454,7 @@ TkpGetShadows(borderPtr, tkwin)
 	    tmp2 = (MAX_INTENSITY + b)/2;
 	    lightColor.blue = (tmp1 > tmp2) ? tmp1 : tmp2;
 	}
-	
+
        /*
         * Allocate the light shadow color and its GC
         */
@@ -483,10 +474,10 @@ TkpGetShadows(borderPtr, tkwin)
     }
     if (borderPtr->visual->map_entries > 2) {
 	/*
-	 * This isn't a monochrome display, but the colormap either
-	 * ran out of entries or didn't have very many to begin with.
-	 * Generate the light shadows with a white stipple and the
-	 * dark shadows with a black stipple.
+	 * This isn't a monochrome display, but the colormap either ran out of
+	 * entries or didn't have very many to begin with. Generate the light
+	 * shadows with a white stipple and the dark shadows with a black
+	 * stipple.
 	 */
 
 	gcValues.foreground = borderPtr->bgColorPtr->pixel;
@@ -504,8 +495,8 @@ TkpGetShadows(borderPtr, tkwin)
 
     /*
      * This is just a measly monochrome display, hardly even worth its
-     * existence on this earth.  Make one shadow a 50% stipple and the
-     * other the opposite of the background.
+     * existence on this earth. Make one shadow a 50% stipple and the other
+     * the opposite of the background.
      */
 
     gcValues.foreground = WhitePixelOfScreen(borderPtr->screen);
@@ -529,8 +520,7 @@ TkpGetShadows(borderPtr, tkwin)
  *
  * TkWinGetBorderPixels --
  *
- *	This routine returns the 5 COLORREFs used to draw a given
- *	3d border.  
+ *	This routine returns the 5 COLORREFs used to draw a given 3d border.
  *
  * Results:
  *	Returns the colors in the specified array.
@@ -542,34 +532,42 @@ TkpGetShadows(borderPtr, tkwin)
  */
 
 COLORREF
-TkWinGetBorderPixels(tkwin, border, which)
-    Tk_Window tkwin;
-    Tk_3DBorder border;
-    int which;			/* One of TK_3D_FLAT_GC, TK_3D_LIGHT_GC,
+TkWinGetBorderPixels(
+    Tk_Window tkwin,
+    Tk_3DBorder border,
+    int which)			/* One of TK_3D_FLAT_GC, TK_3D_LIGHT_GC,
 				 * TK_3D_DARK_GC, TK_3D_LIGHT2, TK_3D_DARK2 */
 {
     WinBorder *borderPtr = (WinBorder *) border;
-    
+
     if (borderPtr->info.lightGC == None) {
 	TkpGetShadows(&borderPtr->info, tkwin);
     }
     switch (which) {
-	case TK_3D_FLAT_GC:
-	    return borderPtr->info.bgColorPtr->pixel;
-	case TK_3D_LIGHT_GC:
-	    if (borderPtr->info.lightColorPtr == NULL) {
-		return WhitePixelOfScreen(borderPtr->info.screen);
-	    }
-	    return borderPtr->info.lightColorPtr->pixel;
-	case TK_3D_DARK_GC:
-	    if (borderPtr->info.darkColorPtr == NULL) {
-		return BlackPixelOfScreen(borderPtr->info.screen);
-	    }
-	    return borderPtr->info.darkColorPtr->pixel;
-	case TK_3D_LIGHT2:
-	    return borderPtr->light2ColorPtr->pixel;
-	case TK_3D_DARK2:
-	    return borderPtr->dark2ColorPtr->pixel;
+    case TK_3D_FLAT_GC:
+	return borderPtr->info.bgColorPtr->pixel;
+    case TK_3D_LIGHT_GC:
+	if (borderPtr->info.lightColorPtr == NULL) {
+	    return WhitePixelOfScreen(borderPtr->info.screen);
+	}
+	return borderPtr->info.lightColorPtr->pixel;
+    case TK_3D_DARK_GC:
+	if (borderPtr->info.darkColorPtr == NULL) {
+	    return BlackPixelOfScreen(borderPtr->info.screen);
+	}
+	return borderPtr->info.darkColorPtr->pixel;
+    case TK_3D_LIGHT2:
+	return borderPtr->light2ColorPtr->pixel;
+    case TK_3D_DARK2:
+	return borderPtr->dark2ColorPtr->pixel;
     }
     return 0;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */