*** empty log message ***

4 files changed, 1573 insertions, 1601 deletions

diff --git a/src/bltGrAxis.C b/src/bltGrAxis.C
index 0f55e58..e860ad4 100644
--- a/src/bltGrAxis.C
+++ b/src/bltGrAxis.C
@@ -154,10 +154,9 @@ static Blt_CustomOption useOption = {
 #define DEF_AXIS_COMMAND		(char *)NULL
 #define DEF_AXIS_DESCENDING		"0"
 #define DEF_AXIS_FOREGROUND		black
-#define DEF_AXIS_GRID_BARCHART		"1"
+#define DEF_AXIS_GRID		        "1"
 #define DEF_AXIS_GRIDCOLOR		gray64
 #define DEF_AXIS_GRIDDASHES		"dot"
-#define DEF_AXIS_GRID_GRAPH		"0"
 #define DEF_AXIS_GRIDLINEWIDTH	"0"
 #define DEF_AXIS_GRIDMINOR		"1"
 #define DEF_AXIS_GRIDMINOR_COLOR	gray64
@@ -373,10 +372,10 @@ static Blt_ConfigSpec configSpecs[] = {
    (char *)NULL, 0, ALL_GRAPHS},
   {BLT_CONFIG_SYNONYM, "-foreground", "color", (char *)NULL, 
    (char *)NULL, 0, ALL_GRAPHS},
-  {BLT_CONFIG_CUSTOM, "-grid", "grid", "Grid", DEF_AXIS_GRID_BARCHART, 
+  {BLT_CONFIG_CUSTOM, "-grid", "grid", "Grid", DEF_AXIS_GRID, 
    Tk_Offset(Axis, flags), BARCHART, 
    &bitmaskGrAxisGridOption},
-  {BLT_CONFIG_CUSTOM, "-grid", "grid", "Grid", DEF_AXIS_GRID_GRAPH, 
+  {BLT_CONFIG_CUSTOM, "-grid", "grid", "Grid", DEF_AXIS_GRID, 
    Tk_Offset(Axis, flags), GRAPH | STRIPCHART, 
    &bitmaskGrAxisGridOption},
   {BLT_CONFIG_COLOR, "-gridcolor", "gridColor", "GridColor", 
diff --git a/src/bltGrElemBar.C b/src/bltGrElemBar.C
index 21ba7a7..2a8f3f6 100644
--- a/src/bltGrElemBar.C
+++ b/src/bltGrElemBar.C
@@ -42,148 +42,148 @@
 
 #define CLAMP(x,l,h)	((x) = (((x)<(l))? (l) : ((x)>(h)) ? (h) : (x)))
 
-#define PointInRectangle(r,x0,y0) \
-	(((x0) <= (int)((r)->x + (r)->width - 1)) && ((x0) >= (int)(r)->x) && \
-	 ((y0) <= (int)((r)->y + (r)->height - 1)) && ((y0) >= (int)(r)->y))
+#define PointInRectangle(r,x0,y0)					\
+  (((x0) <= (int)((r)->x + (r)->width - 1)) && ((x0) >= (int)(r)->x) && \
+   ((y0) <= (int)((r)->y + (r)->height - 1)) && ((y0) >= (int)(r)->y))
 
 typedef struct {
-    float x1, y1, x2, y2;
+  float x1, y1, x2, y2;
 } BarRegion;
 
 typedef struct {
-    const char *name;			/* Pen style identifier.  If NULL, pen
+  const char *name;			/* Pen style identifier.  If NULL, pen
 					 * was statically allocated. */
-    ClassId classId;			/* Type of pen */
-    const char *typeId;			/* String token identifying the type of
+  ClassId classId;			/* Type of pen */
+  const char *typeId;			/* String token identifying the type of
 					 * pen */
-    unsigned int flags;			/* Indicates if the pen element is
+  unsigned int flags;			/* Indicates if the pen element is
 					 * active or normal */
-    int refCount;			/* Reference count for elements using
-					 * this pen. */
-    Tcl_HashEntry *hashPtr;
-    Blt_ConfigSpec *configSpecs;	/* Configuration specifications */
-    PenConfigureProc *configProc;
-    PenDestroyProc *destroyProc;
-    Graph *graphPtr;			/* Graph that the pen is associated
+  int refCount;			/* Reference count for elements using
+				 * this pen. */
+  Tcl_HashEntry *hashPtr;
+  Blt_ConfigSpec *configSpecs;	/* Configuration specifications */
+  PenConfigureProc *configProc;
+  PenDestroyProc *destroyProc;
+  Graph *graphPtr;			/* Graph that the pen is associated
 					 * with. */
-    /* Barchart specific pen fields start here. */
-    XColor *outlineColor;		/* Outline (foreground) color of bar */
-    Tk_3DBorder fill;		/* 3D border and fill (background)
-					 * color */
-    int borderWidth;			/* 3D border width of bar */
-    int relief;				/* Relief of the bar */
-    Pixmap stipple;			/* Stipple */
-    GC fillGC;				/* Graphics context */
-    GC outlineGC;			/* GC for outline of bar. */
-
-    /* Error bar attributes. */
-    int errorBarShow;			/* Describes which error bars to
+  /* Barchart specific pen fields start here. */
+  XColor *outlineColor;		/* Outline (foreground) color of bar */
+  Tk_3DBorder fill;		/* 3D border and fill (background)
+				 * color */
+  int borderWidth;			/* 3D border width of bar */
+  int relief;				/* Relief of the bar */
+  Pixmap stipple;			/* Stipple */
+  GC fillGC;				/* Graphics context */
+  GC outlineGC;			/* GC for outline of bar. */
+
+  /* Error bar attributes. */
+  int errorBarShow;			/* Describes which error bars to
 					 * display: none, x, y, or * both. */
 
-    int errorBarLineWidth;		/* Width of the error bar segments. */
+  int errorBarLineWidth;		/* Width of the error bar segments. */
 
-    int errorBarCapWidth;
-    XColor *errorBarColor;		/* Color of the error bar. */
+  int errorBarCapWidth;
+  XColor *errorBarColor;		/* Color of the error bar. */
 
-    GC errorBarGC;			/* Error bar graphics context. */
+  GC errorBarGC;			/* Error bar graphics context. */
 
-    /* Show value attributes. */
-    int valueShow;			/* Indicates whether to display data
+  /* Show value attributes. */
+  int valueShow;			/* Indicates whether to display data
 					 * value.  Values are x, y, or none. */
 
-    const char *valueFormat;		/* A printf format string. */
-    TextStyle valueStyle;		/* Text attributes (color, font,
-					 * rotation, etc.) of the value. */
+  const char *valueFormat;		/* A printf format string. */
+  TextStyle valueStyle;		/* Text attributes (color, font,
+				 * rotation, etc.) of the value. */
     
 } BarPen;
 
 typedef struct {
-    Weight weight;			/* Weight range where this pen is
+  Weight weight;			/* Weight range where this pen is
 					 * valid. */
-    BarPen *penPtr;			/* Pen to use. */
+  BarPen *penPtr;			/* Pen to use. */
 
-    XRectangle *bars;			/* Indicates starting location in bar
+  XRectangle *bars;			/* Indicates starting location in bar
 					 * array for this pen. */
-    int nBars;				/* # of bar segments for this pen. */
+  int nBars;				/* # of bar segments for this pen. */
 
-    GraphSegments xeb, yeb;		/* X and Y error bars. */
+  GraphSegments xeb, yeb;		/* X and Y error bars. */
 
-    int symbolSize;			/* Size of the pen's symbol scaled to
+  int symbolSize;			/* Size of the pen's symbol scaled to
 					 * the current graph size. */
-    int errorBarCapWidth;		/* Length of the cap ends on each error
-					 * bar. */
+  int errorBarCapWidth;		/* Length of the cap ends on each error
+				 * bar. */
 
 } BarStyle;
 
 typedef struct {
-    GraphObj obj;			/* Must be first field in element. */
-    unsigned int flags;		
-    Tcl_HashEntry *hashPtr;
+  GraphObj obj;			/* Must be first field in element. */
+  unsigned int flags;		
+  Tcl_HashEntry *hashPtr;
 
-    /* Fields specific to elements. */
-    const char *label;			/* Label displayed in legend */
-    unsigned short row, col;		/* Position of the entry in the
+  /* Fields specific to elements. */
+  const char *label;			/* Label displayed in legend */
+  unsigned short row, col;		/* Position of the entry in the
 					 * legend. */
-    int legendRelief;			/* Relief of label in legend. */
-    Axis2d axes;			/* X-axis and Y-axis mapping the
-					 * element */
-    ElemValues x, y, w;			/* Contains array of floating point
+  int legendRelief;			/* Relief of label in legend. */
+  Axis2d axes;			/* X-axis and Y-axis mapping the
+				 * element */
+  ElemValues x, y, w;			/* Contains array of floating point
 					 * graph coordinate values. Also holds
 					 * min/max and the number of
 					 * coordinates */
-    int *activeIndices;			/* Array of indices (malloc-ed) which
+  int *activeIndices;			/* Array of indices (malloc-ed) which
 					 * indicate which data points are active
 					 * (drawn * with "active" colors). */
-    int nActiveIndices;			/* Number of active data points.
+  int nActiveIndices;			/* Number of active data points.
 					 * Special case: if nActiveIndices < 0
 					 * and the active bit is set in "flags",
 					 * then all data * points are drawn
 					 * active. */
-    ElementProcs *procsPtr;
-    Blt_ConfigSpec *configSpecs;	/* Configuration specifications. */
-    BarPen *activePenPtr;		/* Standard Pens */
-    BarPen *normalPenPtr;
-    BarPen *builtinPenPtr;
-    Blt_Chain stylePalette;		/* Palette of pens. */
-
-    /* Symbol scaling */
-    int scaleSymbols;			/* If non-zero, the symbols will scale
+  ElementProcs *procsPtr;
+  Blt_ConfigSpec *configSpecs;	/* Configuration specifications. */
+  BarPen *activePenPtr;		/* Standard Pens */
+  BarPen *normalPenPtr;
+  BarPen *builtinPenPtr;
+  Blt_Chain stylePalette;		/* Palette of pens. */
+
+  /* Symbol scaling */
+  int scaleSymbols;			/* If non-zero, the symbols will scale
 					 * in size as the graph is zoomed
 					 * in/out.  */
-    double xRange, yRange;		/* Initial X-axis and Y-axis ranges:
+  double xRange, yRange;		/* Initial X-axis and Y-axis ranges:
 					 * used to scale the size of element's
 					 * symbol. */
-    int state;
-    Blt_ChainLink link;
+  int state;
+  Blt_ChainLink link;
 
-    /* Fields specific to the barchart element */
+  /* Fields specific to the barchart element */
 
-    double barWidth;
-    const char *groupName;
+  double barWidth;
+  const char *groupName;
 
-    int *barToData;
-    XRectangle *bars;		       /* Array of rectangles comprising the bar
+  int *barToData;
+  XRectangle *bars;		       /* Array of rectangles comprising the bar
 					* segments of the element. */
-    int *activeToData;
-    XRectangle *activeRects;
+  int *activeToData;
+  XRectangle *activeRects;
 
-    int nBars;				/* # of visible bar segments for
+  int nBars;				/* # of visible bar segments for
 					 * element */
-    int nActive;
+  int nActive;
 
-    int xPad;				/* Spacing on either side of bar */
+  int xPad;				/* Spacing on either side of bar */
 
-    ElemValues xError;			/* Relative/symmetric X error values. */
-    ElemValues yError;			/* Relative/symmetric Y error values. */
-    ElemValues xHigh, xLow;		/* Absolute/asymmetric X-coordinate
+  ElemValues xError;			/* Relative/symmetric X error values. */
+  ElemValues yError;			/* Relative/symmetric Y error values. */
+  ElemValues xHigh, xLow;		/* Absolute/asymmetric X-coordinate
 					 * high/low error values. */
-    ElemValues yHigh, yLow;		/* Absolute/asymmetric Y-coordinate
+  ElemValues yHigh, yLow;		/* Absolute/asymmetric Y-coordinate
 					 * high/low error values. */
-    BarPen builtinPen;
+  BarPen builtinPen;
 
-    GraphSegments xeb, yeb;
+  GraphSegments xeb, yeb;
 
-    int errorBarCapWidth;		/* Length of cap on error bars */
+  int errorBarCapWidth;		/* Length of cap on error bars */
 } BarElement;
 
 extern Blt_CustomOption bltBarPenOption;
@@ -197,12 +197,12 @@ extern Blt_CustomOption bltBarStylesOption;
 #define DEF_BAR_ACTIVE_PEN		"activeBar"
 #define DEF_BAR_AXIS_X			"x"
 #define DEF_BAR_AXIS_Y			"y"
-#define DEF_BAR_BACKGROUND		"navyblue"
+#define DEF_BAR_BACKGROUND		navyblue
+#define DEF_BAR_FOREGROUND		bblue
 #define DEF_BAR_BORDERWIDTH		STD_BORDERWIDTH
 #define DEF_BAR_ERRORBAR_COLOR		"defcolor"
 #define DEF_BAR_ERRORBAR_LINE_WIDTH	"1"
 #define DEF_BAR_ERRORBAR_CAP_WIDTH	"1"
-#define DEF_BAR_FOREGROUND		bblue
 #define DEF_BAR_HIDE			"no"
 #define DEF_BAR_LABEL_RELIEF		"flat"
 #define DEF_BAR_NORMAL_STIPPLE		""
@@ -292,9 +292,9 @@ static Blt_ConfigSpec barPenConfigSpecs[] = {
 };
 
 Blt_CustomOption bitmaskBarElemHideOption =
-{
-  ObjToBitmaskProc, BitmaskToObjProc, NULL, (ClientData)HIDE
-};
+  {
+    ObjToBitmaskProc, BitmaskToObjProc, NULL, (ClientData)HIDE
+  };
 
 static Blt_ConfigSpec barElemConfigSpecs[] = {
   {BLT_CONFIG_CUSTOM, "-activepen", "activePen", "ActivePen",
@@ -424,150 +424,133 @@ static ElementToPostScriptProc NormalBarToPostScriptProc;
 static ElementSymbolToPostScriptProc SymbolToPostScriptProc;
 static ElementMapProc MapBarProc;
 
-/*
- *---------------------------------------------------------------------------
- * Custom option parse and print procedures
- *---------------------------------------------------------------------------
- */
-
-/* 
- * Zero out the style's number of bars and errorbars. 
- */
-static void
-ResetStylePalette(Blt_Chain stylePalette)
+static void ResetStylePalette(Blt_Chain stylePalette)
 {
-    Blt_ChainLink link;
+  Blt_ChainLink link;
 
-    for (link = Blt_Chain_FirstLink(stylePalette); link != NULL; 
-	 link = Blt_Chain_NextLink(link)) {
-	BarStyle *stylePtr;
+  for (link = Blt_Chain_FirstLink(stylePalette); link != NULL; 
+       link = Blt_Chain_NextLink(link)) {
+    BarStyle *stylePtr;
 
-	stylePtr = Blt_Chain_GetValue(link);
-	stylePtr->xeb.length = stylePtr->yeb.length = 0;
-	stylePtr->nBars = 0;
-    }
+    stylePtr = Blt_Chain_GetValue(link);
+    stylePtr->xeb.length = stylePtr->yeb.length = 0;
+    stylePtr->nBars = 0;
+  }
 }
 
-static int
-ConfigureBarPen(Graph *graphPtr, BarPen *penPtr)
+static int ConfigureBarPen(Graph *graphPtr, BarPen *penPtr)
 {
-    XGCValues gcValues;
-    unsigned long gcMask;
-    GC newGC;
-    long defColor;
-    int screenNum;
-
-    screenNum = Tk_ScreenNumber(graphPtr->tkwin);
-    gcMask = GCForeground | GCLineWidth;
-    gcValues.line_width = LineWidth(penPtr->errorBarLineWidth);
-
-    if (penPtr->outlineColor != NULL) {
-	defColor = penPtr->outlineColor->pixel;
-	gcValues.foreground = penPtr->outlineColor->pixel;
-    } else if (penPtr->fill != NULL) {
-	defColor = Tk_3DBorderColor(penPtr->fill)->pixel;
-	gcValues.foreground = defColor;
-    } else {
-	defColor = BlackPixel(graphPtr->display, screenNum);
-    }
-    newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues);
-    if (penPtr->outlineGC != NULL) {
-	Tk_FreeGC(graphPtr->display, penPtr->outlineGC);
-    }
-    penPtr->outlineGC = newGC;
-
-    newGC = NULL;
-    if (penPtr->stipple != None) {
-	/* Handle old-style -stipple specially. */
-	gcMask = GCForeground | GCBackground | GCFillStyle | GCStipple;
-	gcValues.foreground = BlackPixel(graphPtr->display, screenNum);
-	gcValues.background = WhitePixel(graphPtr->display, screenNum);
-	if (penPtr->fill != NULL) {
-	    gcValues.foreground = Tk_3DBorderColor(penPtr->fill)->pixel;
-	} else if (penPtr->outlineColor != NULL) {
-	    gcValues.foreground = penPtr->outlineColor->pixel;
-	}
-	gcValues.stipple = penPtr->stipple;
-	gcValues.fill_style = FillStippled;
-	newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues);
-    }
-    if (penPtr->fillGC != NULL) {
-	Tk_FreeGC(graphPtr->display, penPtr->fillGC);
-    }
-    penPtr->fillGC = newGC;
-
-    gcMask = GCForeground | GCLineWidth;
-    if (penPtr->errorBarColor == COLOR_DEFAULT) {
-	gcValues.foreground = defColor;
-    } else {
-	gcValues.foreground = penPtr->errorBarColor->pixel;
+  XGCValues gcValues;
+  unsigned long gcMask;
+  GC newGC;
+  long defColor;
+  int screenNum;
+
+  screenNum = Tk_ScreenNumber(graphPtr->tkwin);
+  gcMask = GCForeground | GCLineWidth;
+  gcValues.line_width = LineWidth(penPtr->errorBarLineWidth);
+
+  if (penPtr->outlineColor != NULL) {
+    defColor = penPtr->outlineColor->pixel;
+    gcValues.foreground = penPtr->outlineColor->pixel;
+  } else if (penPtr->fill != NULL) {
+    defColor = Tk_3DBorderColor(penPtr->fill)->pixel;
+    gcValues.foreground = defColor;
+  } else {
+    defColor = BlackPixel(graphPtr->display, screenNum);
+  }
+  newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues);
+  if (penPtr->outlineGC != NULL) {
+    Tk_FreeGC(graphPtr->display, penPtr->outlineGC);
+  }
+  penPtr->outlineGC = newGC;
+
+  newGC = NULL;
+  if (penPtr->stipple != None) {
+    /* Handle old-style -stipple specially. */
+    gcMask = GCForeground | GCBackground | GCFillStyle | GCStipple;
+    gcValues.foreground = BlackPixel(graphPtr->display, screenNum);
+    gcValues.background = WhitePixel(graphPtr->display, screenNum);
+    if (penPtr->fill != NULL) {
+      gcValues.foreground = Tk_3DBorderColor(penPtr->fill)->pixel;
+    } else if (penPtr->outlineColor != NULL) {
+      gcValues.foreground = penPtr->outlineColor->pixel;
     }
-    gcValues.line_width = LineWidth(penPtr->errorBarLineWidth);
+    gcValues.stipple = penPtr->stipple;
+    gcValues.fill_style = FillStippled;
     newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues);
-    if (penPtr->errorBarGC != NULL) {
-	Tk_FreeGC(graphPtr->display, penPtr->errorBarGC);
-    }
-    penPtr->errorBarGC = newGC;
-    return TCL_OK;
+  }
+  if (penPtr->fillGC != NULL) {
+    Tk_FreeGC(graphPtr->display, penPtr->fillGC);
+  }
+  penPtr->fillGC = newGC;
+
+  gcMask = GCForeground | GCLineWidth;
+  if (penPtr->errorBarColor == COLOR_DEFAULT) {
+    gcValues.foreground = defColor;
+  } else {
+    gcValues.foreground = penPtr->errorBarColor->pixel;
+  }
+  gcValues.line_width = LineWidth(penPtr->errorBarLineWidth);
+  newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues);
+  if (penPtr->errorBarGC != NULL) {
+    Tk_FreeGC(graphPtr->display, penPtr->errorBarGC);
+  }
+  penPtr->errorBarGC = newGC;
+  return TCL_OK;
 }
 
-static void
-DestroyBarPen(Graph *graphPtr, BarPen *penPtr)
+static void DestroyBarPen(Graph *graphPtr, BarPen *penPtr)
 {
-    Blt_Ts_FreeStyle(graphPtr->display, &penPtr->valueStyle);
-    if (penPtr->outlineGC != NULL) {
-	Tk_FreeGC(graphPtr->display, penPtr->outlineGC);
-    }
-    if (penPtr->fillGC != NULL) {
-	Tk_FreeGC(graphPtr->display, penPtr->fillGC);
-    }
-    if (penPtr->errorBarGC != NULL) {
-	Tk_FreeGC(graphPtr->display, penPtr->errorBarGC);
-    }
+  Blt_Ts_FreeStyle(graphPtr->display, &penPtr->valueStyle);
+  if (penPtr->outlineGC != NULL) {
+    Tk_FreeGC(graphPtr->display, penPtr->outlineGC);
+  }
+  if (penPtr->fillGC != NULL) {
+    Tk_FreeGC(graphPtr->display, penPtr->fillGC);
+  }
+  if (penPtr->errorBarGC != NULL) {
+    Tk_FreeGC(graphPtr->display, penPtr->errorBarGC);
+  }
 }
 
-static int
-ConfigureBarPenProc(Graph *graphPtr, Pen *basePtr)
+static int ConfigureBarPenProc(Graph *graphPtr, Pen *basePtr)
 {
-    return ConfigureBarPen(graphPtr, (BarPen *)basePtr);
+  return ConfigureBarPen(graphPtr, (BarPen *)basePtr);
 }
 
-static void
-DestroyBarPenProc(Graph *graphPtr, Pen *basePtr)
+static void DestroyBarPenProc(Graph *graphPtr, Pen *basePtr)
 {
-    DestroyBarPen(graphPtr, (BarPen *)basePtr);
+  DestroyBarPen(graphPtr, (BarPen *)basePtr);
 }
 
-
-static void
-InitializeBarPen(BarPen *penPtr)
+static void InitializeBarPen(BarPen *penPtr)
 {
-    /* Generic fields common to all pen types. */
-    penPtr->configProc = ConfigureBarPenProc;
-    penPtr->destroyProc = DestroyBarPenProc;
-    penPtr->flags = NORMAL_PEN;
-    penPtr->configSpecs = barPenConfigSpecs;
-
-    /* Initialize fields specific to bar pens. */
-    Blt_Ts_InitStyle(penPtr->valueStyle);
-    penPtr->relief = TK_RELIEF_RAISED;
-    penPtr->valueShow = SHOW_NONE;
-    penPtr->borderWidth = 2;
-    penPtr->errorBarShow = SHOW_BOTH;
+  /* Generic fields common to all pen types. */
+  penPtr->configProc = ConfigureBarPenProc;
+  penPtr->destroyProc = DestroyBarPenProc;
+  penPtr->flags = NORMAL_PEN;
+  penPtr->configSpecs = barPenConfigSpecs;
+
+  /* Initialize fields specific to bar pens. */
+  Blt_Ts_InitStyle(penPtr->valueStyle);
+  penPtr->relief = TK_RELIEF_RAISED;
+  penPtr->valueShow = SHOW_NONE;
+  penPtr->borderWidth = 2;
+  penPtr->errorBarShow = SHOW_BOTH;
 }
 
-Pen *
-Blt_BarPen(const char *penName)
+Pen* Blt_BarPen(const char *penName)
 {
-    BarPen *penPtr;
-
-    penPtr = calloc(1, sizeof(BarPen));
-    InitializeBarPen(penPtr);
-    penPtr->name = Blt_Strdup(penName);
-    if (strcmp(penName, "activeBar") == 0) {
-	penPtr->flags = ACTIVE_PEN;
-    }
-    return (Pen *)penPtr;
+  BarPen *penPtr;
+
+  penPtr = calloc(1, sizeof(BarPen));
+  InitializeBarPen(penPtr);
+  penPtr->name = Blt_Strdup(penName);
+  if (strcmp(penName, "activeBar") == 0) {
+    penPtr->flags = ACTIVE_PEN;
+  }
+  return (Pen *)penPtr;
 }
 
 /*
@@ -588,32 +571,32 @@ Blt_BarPen(const char *penName)
  *
  *---------------------------------------------------------------------------
  */
-static void
-CheckBarStacks(Graph *graphPtr, Axis2d *pairPtr, double *minPtr, double *maxPtr)
+static void CheckBarStacks(Graph *graphPtr, Axis2d *pairPtr, 
+			   double *minPtr, double *maxPtr)
 {
-    BarGroup *gp, *gend;
-
-    if ((graphPtr->mode != BARS_STACKED) || (graphPtr->nBarGroups == 0)) {
-	return;
-    }
-    for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; gp < gend;
-	 gp++) {
-	if ((gp->axes.x == pairPtr->x) && (gp->axes.y == pairPtr->y)) {
-	    /*
-	     * Check if any of the y-values (because of stacking) are greater
-	     * than the current limits of the graph.
-	     */
-	    if (gp->sum < 0.0f) {
-		if (*minPtr > gp->sum) {
-		    *minPtr = gp->sum;
-		}
-	    } else {
-		if (*maxPtr < gp->sum) {
-		    *maxPtr = gp->sum;
-		}
-	    }
+  BarGroup *gp, *gend;
+
+  if ((graphPtr->mode != BARS_STACKED) || (graphPtr->nBarGroups == 0)) {
+    return;
+  }
+  for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; gp < gend;
+       gp++) {
+    if ((gp->axes.x == pairPtr->x) && (gp->axes.y == pairPtr->y)) {
+      /*
+       * Check if any of the y-values (because of stacking) are greater
+       * than the current limits of the graph.
+       */
+      if (gp->sum < 0.0f) {
+	if (*minPtr > gp->sum) {
+	  *minPtr = gp->sum;
 	}
+      } else {
+	if (*maxPtr < gp->sum) {
+	  *maxPtr = gp->sum;
+	}
+      }
     }
+  }
 }
 
 /*
@@ -635,176 +618,174 @@ CheckBarStacks(Graph *graphPtr, Axis2d *pairPtr, double *minPtr, double *maxPtr)
  *
  *---------------------------------------------------------------------------
  */
-/*ARGSUSED*/
-static int
-ConfigureBarProc(Graph *graphPtr, Element *basePtr)
-{
-    BarElement *elemPtr = (BarElement *)basePtr;
-    Blt_ChainLink link;
-    BarStyle *stylePtr;
-
-    if (ConfigureBarPen(graphPtr, elemPtr->builtinPenPtr)!= TCL_OK) {
-	return TCL_ERROR;
-    }
-    /*
-     * Point to the static normal pen if no external pens have been selected.
-     */
-    link = Blt_Chain_FirstLink(elemPtr->stylePalette);
-    if (link == NULL) {
-	link = Blt_Chain_AllocLink(sizeof(BarStyle));
-	Blt_Chain_LinkAfter(elemPtr->stylePalette, link, NULL);
-    }
-    stylePtr = Blt_Chain_GetValue(link);
-    stylePtr->penPtr = NORMALPEN(elemPtr);
 
-    if (Blt_ConfigModified(elemPtr->configSpecs, "-barwidth", "-*data",
-	    "-map*", "-label", "-hide", "-x", "-y", (char *)NULL)) {
-	elemPtr->flags |= MAP_ITEM;
-    }
-    return TCL_OK;
+static int ConfigureBarProc(Graph *graphPtr, Element *basePtr)
+{
+  BarElement *elemPtr = (BarElement *)basePtr;
+  Blt_ChainLink link;
+  BarStyle *stylePtr;
+
+  if (ConfigureBarPen(graphPtr, elemPtr->builtinPenPtr)!= TCL_OK) {
+    return TCL_ERROR;
+  }
+  /*
+   * Point to the static normal pen if no external pens have been selected.
+   */
+  link = Blt_Chain_FirstLink(elemPtr->stylePalette);
+  if (link == NULL) {
+    link = Blt_Chain_AllocLink(sizeof(BarStyle));
+    Blt_Chain_LinkAfter(elemPtr->stylePalette, link, NULL);
+  }
+  stylePtr = Blt_Chain_GetValue(link);
+  stylePtr->penPtr = NORMALPEN(elemPtr);
+
+  if (Blt_ConfigModified(elemPtr->configSpecs, "-barwidth", "-*data",
+			 "-map*", "-label", "-hide", "-x", "-y", (char *)NULL)) {
+    elemPtr->flags |= MAP_ITEM;
+  }
+  return TCL_OK;
 }
 
-static void
-GetBarExtentsProc(Element *basePtr, Region2d *regPtr)
+static void GetBarExtentsProc(Element *basePtr, Region2d *regPtr)
 {
-    BarElement *elemPtr = (BarElement *)basePtr;
-    Graph *graphPtr;
-    double middle, barWidth;
-    int nPoints;
-
-    graphPtr = elemPtr->obj.graphPtr;
-    regPtr->top = regPtr->left = DBL_MAX;
-    regPtr->bottom = regPtr->right = -DBL_MAX;
-
-    nPoints = NUMBEROFPOINTS(elemPtr);
-    if (nPoints < 1) {
-	return;				/* No data points */
-    }
-    barWidth = graphPtr->barWidth;
-    if (elemPtr->barWidth > 0.0f) {
-	barWidth = elemPtr->barWidth;
-    }
-    middle = 0.5;
-    regPtr->left = elemPtr->x.min - middle;
-    regPtr->right = elemPtr->x.max + middle;
-
-    regPtr->top = elemPtr->y.min;
-    regPtr->bottom = elemPtr->y.max;
-    if (regPtr->bottom < graphPtr->baseline) {
-	regPtr->bottom = graphPtr->baseline;
-    }
-    /*
-     * Handle stacked bar elements specially.
-     *
-     * If element is stacked, the sum of its ordinates may be outside the
-     * minimum/maximum limits of the element's data points.
-     */
-    if ((graphPtr->mode == BARS_STACKED) && (graphPtr->nBarGroups > 0)) {
-	CheckBarStacks(graphPtr, &elemPtr->axes, &regPtr->top, &regPtr->bottom);
-    }
-    /* Warning: You get what you deserve if the x-axis is logScale */
-    if (elemPtr->axes.x->logScale) {
-	regPtr->left = Blt_FindElemValuesMinimum(&elemPtr->x, DBL_MIN) + 
-	    middle;
-    }
-    /* Fix y-min limits for barchart */
-    if (elemPtr->axes.y->logScale) {
- 	if ((regPtr->top <= 0.0) || (regPtr->top > 1.0)) {
-	    regPtr->top = 1.0;
-	}
-    } else {
-	if (regPtr->top > 0.0) {
-	    regPtr->top = 0.0;
-	}
-    }
-    /* Correct the extents for error bars if they exist. */
-    if (elemPtr->xError.nValues > 0) {
-	int i;
+  BarElement *elemPtr = (BarElement *)basePtr;
+  Graph *graphPtr;
+  double middle, barWidth;
+  int nPoints;
+
+  graphPtr = elemPtr->obj.graphPtr;
+  regPtr->top = regPtr->left = DBL_MAX;
+  regPtr->bottom = regPtr->right = -DBL_MAX;
+
+  nPoints = NUMBEROFPOINTS(elemPtr);
+  if (nPoints < 1) {
+    return;				/* No data points */
+  }
+  barWidth = graphPtr->barWidth;
+  if (elemPtr->barWidth > 0.0f) {
+    barWidth = elemPtr->barWidth;
+  }
+  middle = 0.5;
+  regPtr->left = elemPtr->x.min - middle;
+  regPtr->right = elemPtr->x.max + middle;
+
+  regPtr->top = elemPtr->y.min;
+  regPtr->bottom = elemPtr->y.max;
+  if (regPtr->bottom < graphPtr->baseline) {
+    regPtr->bottom = graphPtr->baseline;
+  }
+  /*
+   * Handle stacked bar elements specially.
+   *
+   * If element is stacked, the sum of its ordinates may be outside the
+   * minimum/maximum limits of the element's data points.
+   */
+  if ((graphPtr->mode == BARS_STACKED) && (graphPtr->nBarGroups > 0)) {
+    CheckBarStacks(graphPtr, &elemPtr->axes, &regPtr->top, &regPtr->bottom);
+  }
+  /* Warning: You get what you deserve if the x-axis is logScale */
+  if (elemPtr->axes.x->logScale) {
+    regPtr->left = Blt_FindElemValuesMinimum(&elemPtr->x, DBL_MIN) + 
+      middle;
+  }
+  /* Fix y-min limits for barchart */
+  if (elemPtr->axes.y->logScale) {
+    if ((regPtr->top <= 0.0) || (regPtr->top > 1.0)) {
+      regPtr->top = 1.0;
+    }
+  } else {
+    if (regPtr->top > 0.0) {
+      regPtr->top = 0.0;
+    }
+  }
+  /* Correct the extents for error bars if they exist. */
+  if (elemPtr->xError.nValues > 0) {
+    int i;
 	
-	/* Correct the data limits for error bars */
-	nPoints = MIN(elemPtr->xError.nValues, nPoints);
-	for (i = 0; i < nPoints; i++) {
-	    double x;
-
-	    x = elemPtr->x.values[i] + elemPtr->xError.values[i];
-	    if (x > regPtr->right) {
-		regPtr->right = x;
-	    }
-	    x = elemPtr->x.values[i] - elemPtr->xError.values[i];
-	    if (elemPtr->axes.x->logScale) {
-		if (x < 0.0) {
-		    x = -x;		/* Mirror negative values, instead of
-					 * ignoring them. */
-		}
-		if ((x > DBL_MIN) && (x < regPtr->left)) {
-		    regPtr->left = x;
-		}
-	    } else if (x < regPtr->left) {
-		regPtr->left = x;
-	    }
-	}		     
-    } else {
-	if ((elemPtr->xHigh.nValues > 0) && 
-	    (elemPtr->xHigh.max > regPtr->right)) {
-	    regPtr->right = elemPtr->xHigh.max;
+    /* Correct the data limits for error bars */
+    nPoints = MIN(elemPtr->xError.nValues, nPoints);
+    for (i = 0; i < nPoints; i++) {
+      double x;
+
+      x = elemPtr->x.values[i] + elemPtr->xError.values[i];
+      if (x > regPtr->right) {
+	regPtr->right = x;
+      }
+      x = elemPtr->x.values[i] - elemPtr->xError.values[i];
+      if (elemPtr->axes.x->logScale) {
+	if (x < 0.0) {
+	  x = -x;		/* Mirror negative values, instead of
+				 * ignoring them. */
 	}
-	if (elemPtr->xLow.nValues > 0) {
-	    double left;
-	    
-	    if ((elemPtr->xLow.min <= 0.0) && 
-		(elemPtr->axes.x->logScale)) {
-		left = Blt_FindElemValuesMinimum(&elemPtr->xLow, DBL_MIN);
-	    } else {
-		left = elemPtr->xLow.min;
-	    }
-	    if (left < regPtr->left) {
-		regPtr->left = left;
-	    }
+	if ((x > DBL_MIN) && (x < regPtr->left)) {
+	  regPtr->left = x;
 	}
-    }
-    if (elemPtr->yError.nValues > 0) {
-	int i;
+      } else if (x < regPtr->left) {
+	regPtr->left = x;
+      }
+    }		     
+  } else {
+    if ((elemPtr->xHigh.nValues > 0) && 
+	(elemPtr->xHigh.max > regPtr->right)) {
+      regPtr->right = elemPtr->xHigh.max;
+    }
+    if (elemPtr->xLow.nValues > 0) {
+      double left;
+	    
+      if ((elemPtr->xLow.min <= 0.0) && 
+	  (elemPtr->axes.x->logScale)) {
+	left = Blt_FindElemValuesMinimum(&elemPtr->xLow, DBL_MIN);
+      } else {
+	left = elemPtr->xLow.min;
+      }
+      if (left < regPtr->left) {
+	regPtr->left = left;
+      }
+    }
+  }
+  if (elemPtr->yError.nValues > 0) {
+    int i;
 	
-	nPoints = MIN(elemPtr->yError.nValues, nPoints);
-	for (i = 0; i < nPoints; i++) {
-	    double y;
-
-	    y = elemPtr->y.values[i] + elemPtr->yError.values[i];
-	    if (y > regPtr->bottom) {
-		regPtr->bottom = y;
-	    }
-	    y = elemPtr->y.values[i] - elemPtr->yError.values[i];
-	    if (elemPtr->axes.y->logScale) {
-		if (y < 0.0) {
-		    y = -y;		/* Mirror negative values, instead of
-					 * ignoring them. */
-		}
-		if ((y > DBL_MIN) && (y < regPtr->left)) {
-		    regPtr->top = y;
-		}
-	    } else if (y < regPtr->top) {
-		regPtr->top = y;
-	    }
-	}		     
-    } else {
-	if ((elemPtr->yHigh.nValues > 0) && 
-	    (elemPtr->yHigh.max > regPtr->bottom)) {
-	    regPtr->bottom = elemPtr->yHigh.max;
+    nPoints = MIN(elemPtr->yError.nValues, nPoints);
+    for (i = 0; i < nPoints; i++) {
+      double y;
+
+      y = elemPtr->y.values[i] + elemPtr->yError.values[i];
+      if (y > regPtr->bottom) {
+	regPtr->bottom = y;
+      }
+      y = elemPtr->y.values[i] - elemPtr->yError.values[i];
+      if (elemPtr->axes.y->logScale) {
+	if (y < 0.0) {
+	  y = -y;		/* Mirror negative values, instead of
+				 * ignoring them. */
 	}
-	if (elemPtr->yLow.nValues > 0) {
-	    double top;
-	    
-	    if ((elemPtr->yLow.min <= 0.0) && 
-		(elemPtr->axes.y->logScale)) {
-		top = Blt_FindElemValuesMinimum(&elemPtr->yLow, DBL_MIN);
-	    } else {
-		top = elemPtr->yLow.min;
-	    }
-	    if (top < regPtr->top) {
-		regPtr->top = top;
-	    }
+	if ((y > DBL_MIN) && (y < regPtr->left)) {
+	  regPtr->top = y;
 	}
-    }
+      } else if (y < regPtr->top) {
+	regPtr->top = y;
+      }
+    }		     
+  } else {
+    if ((elemPtr->yHigh.nValues > 0) && 
+	(elemPtr->yHigh.max > regPtr->bottom)) {
+      regPtr->bottom = elemPtr->yHigh.max;
+    }
+    if (elemPtr->yLow.nValues > 0) {
+      double top;
+	    
+      if ((elemPtr->yLow.min <= 0.0) && 
+	  (elemPtr->axes.y->logScale)) {
+	top = Blt_FindElemValuesMinimum(&elemPtr->yLow, DBL_MIN);
+      } else {
+	top = elemPtr->yLow.min;
+      }
+      if (top < regPtr->top) {
+	regPtr->top = top;
+      }
+    }
+  }
 }
 
 /*
@@ -823,70 +804,69 @@ GetBarExtentsProc(Element *basePtr, Region2d *regPtr)
  *
  *---------------------------------------------------------------------------
  */
-/*ARGSUSED*/
-static void
-ClosestBarProc(
-    Graph *graphPtr,			/* Not used. */
-    Element *basePtr,			/* Bar element */
-    ClosestSearch *searchPtr)		/* Information about closest point in
-					 * element */
-{
-    BarElement *elemPtr = (BarElement *)basePtr;
-    XRectangle *bp;
-    double minDist;
-    int imin;
-    int i;
 
-    minDist = searchPtr->dist;
-    imin = 0;
+static void ClosestBarProc(
+			   Graph *graphPtr,			/* Not used. */
+			   Element *basePtr,			/* Bar element */
+			   ClosestSearch *searchPtr)		/* Information about closest point in
+								 * element */
+{
+  BarElement *elemPtr = (BarElement *)basePtr;
+  XRectangle *bp;
+  double minDist;
+  int imin;
+  int i;
+
+  minDist = searchPtr->dist;
+  imin = 0;
     
-    for (bp = elemPtr->bars, i = 0; i < elemPtr->nBars; i++, bp++) {
-	Point2d *pp, *pend;
-	Point2d outline[5];
-	double left, right, top, bottom;
-
-	if (PointInRectangle(bp, searchPtr->x, searchPtr->y)) {
-	    imin = elemPtr->barToData[i];
-	    minDist = 0.0;
-	    break;
-	}
-	left = bp->x, top = bp->y;
-	right = (double)(bp->x + bp->width);
-	bottom = (double)(bp->y + bp->height);
-	outline[4].x = outline[3].x = outline[0].x = left;
-	outline[4].y = outline[1].y = outline[0].y = top;
-	outline[2].x = outline[1].x = right;
-	outline[3].y = outline[2].y = bottom;
-
-	for (pp = outline, pend = outline + 4; pp < pend; pp++) {
-	    Point2d t;
-	    double dist;
-
-	    t = Blt_GetProjection(searchPtr->x, searchPtr->y, pp, pp + 1);
-	    if (t.x > right) {
-		t.x = right;
-	    } else if (t.x < left) {
-		t.x = left;
-	    }
-	    if (t.y > bottom) {
-		t.y = bottom;
-	    } else if (t.y < top) {
-		t.y = top;
-	    }
-	    dist = hypot((t.x - searchPtr->x), (t.y - searchPtr->y));
-	    if (dist < minDist) {
-		minDist = dist;
-		imin = elemPtr->barToData[i];
-	    }
-	}
-    }
-    if (minDist < searchPtr->dist) {
-	searchPtr->elemPtr = (Element *)elemPtr;
-	searchPtr->dist = minDist;
-	searchPtr->index = imin;
-	searchPtr->point.x = (double)elemPtr->x.values[imin];
-	searchPtr->point.y = (double)elemPtr->y.values[imin];
-    }
+  for (bp = elemPtr->bars, i = 0; i < elemPtr->nBars; i++, bp++) {
+    Point2d *pp, *pend;
+    Point2d outline[5];
+    double left, right, top, bottom;
+
+    if (PointInRectangle(bp, searchPtr->x, searchPtr->y)) {
+      imin = elemPtr->barToData[i];
+      minDist = 0.0;
+      break;
+    }
+    left = bp->x, top = bp->y;
+    right = (double)(bp->x + bp->width);
+    bottom = (double)(bp->y + bp->height);
+    outline[4].x = outline[3].x = outline[0].x = left;
+    outline[4].y = outline[1].y = outline[0].y = top;
+    outline[2].x = outline[1].x = right;
+    outline[3].y = outline[2].y = bottom;
+
+    for (pp = outline, pend = outline + 4; pp < pend; pp++) {
+      Point2d t;
+      double dist;
+
+      t = Blt_GetProjection(searchPtr->x, searchPtr->y, pp, pp + 1);
+      if (t.x > right) {
+	t.x = right;
+      } else if (t.x < left) {
+	t.x = left;
+      }
+      if (t.y > bottom) {
+	t.y = bottom;
+      } else if (t.y < top) {
+	t.y = top;
+      }
+      dist = hypot((t.x - searchPtr->x), (t.y - searchPtr->y));
+      if (dist < minDist) {
+	minDist = dist;
+	imin = elemPtr->barToData[i];
+      }
+    }
+  }
+  if (minDist < searchPtr->dist) {
+    searchPtr->elemPtr = (Element *)elemPtr;
+    searchPtr->dist = minDist;
+    searchPtr->index = imin;
+    searchPtr->point.x = (double)elemPtr->x.values[imin];
+    searchPtr->point.y = (double)elemPtr->y.values[imin];
+  }
 }
 
 /*
@@ -905,123 +885,123 @@ ClosestBarProc(
  *
  *---------------------------------------------------------------------------
  */
-static void
-MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
+
+static void MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
 {
-    if (Blt_Chain_GetLength(elemPtr->stylePalette) < 2) {
-	Blt_ChainLink link;
-	BarStyle *stylePtr;
-
-	link = Blt_Chain_FirstLink(elemPtr->stylePalette);
-
-	stylePtr = Blt_Chain_GetValue(link);
-	stylePtr->nBars = elemPtr->nBars;
-	stylePtr->bars = elemPtr->bars;
-	stylePtr->symbolSize = elemPtr->bars->width / 2;
-	stylePtr->xeb.length = elemPtr->xeb.length;
-	stylePtr->xeb.segments = elemPtr->xeb.segments;
-	stylePtr->yeb.length = elemPtr->yeb.length;
-	stylePtr->yeb.segments = elemPtr->yeb.segments;
-	return;
-    }
-    /* We have more than one style. Group bar segments of like pen styles
-     * together.  */
-
-    if (elemPtr->nBars > 0) {
-	Blt_ChainLink link;
-	XRectangle *bars, *bp;
-	int *ip, *barToData;
-
-	bars = malloc(elemPtr->nBars * sizeof(XRectangle));
-	barToData = malloc(elemPtr->nBars * sizeof(int));
-	bp = bars, ip = barToData;
-	for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; 
-	     link = Blt_Chain_NextLink(link)) {
-	    BarStyle *stylePtr;
-	    int i;
-
-	    stylePtr = Blt_Chain_GetValue(link);
-	    stylePtr->symbolSize = bp->width / 2;
-	    stylePtr->bars = bp;
-	    for (i = 0; i < elemPtr->nBars; i++) {
-		int iData;
-
-		iData = elemPtr->barToData[i];
-		if (dataToStyle[iData] == stylePtr) {
-		    *bp++ = elemPtr->bars[i];
-		    *ip++ = iData;
-		}
-	    }
-	    stylePtr->nBars = bp - stylePtr->bars;
+  if (Blt_Chain_GetLength(elemPtr->stylePalette) < 2) {
+    Blt_ChainLink link;
+    BarStyle *stylePtr;
+
+    link = Blt_Chain_FirstLink(elemPtr->stylePalette);
+
+    stylePtr = Blt_Chain_GetValue(link);
+    stylePtr->nBars = elemPtr->nBars;
+    stylePtr->bars = elemPtr->bars;
+    stylePtr->symbolSize = elemPtr->bars->width / 2;
+    stylePtr->xeb.length = elemPtr->xeb.length;
+    stylePtr->xeb.segments = elemPtr->xeb.segments;
+    stylePtr->yeb.length = elemPtr->yeb.length;
+    stylePtr->yeb.segments = elemPtr->yeb.segments;
+    return;
+  }
+  /* We have more than one style. Group bar segments of like pen styles
+   * together.  */
+
+  if (elemPtr->nBars > 0) {
+    Blt_ChainLink link;
+    XRectangle *bars, *bp;
+    int *ip, *barToData;
+
+    bars = malloc(elemPtr->nBars * sizeof(XRectangle));
+    barToData = malloc(elemPtr->nBars * sizeof(int));
+    bp = bars, ip = barToData;
+    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; 
+	 link = Blt_Chain_NextLink(link)) {
+      BarStyle *stylePtr;
+      int i;
+
+      stylePtr = Blt_Chain_GetValue(link);
+      stylePtr->symbolSize = bp->width / 2;
+      stylePtr->bars = bp;
+      for (i = 0; i < elemPtr->nBars; i++) {
+	int iData;
+
+	iData = elemPtr->barToData[i];
+	if (dataToStyle[iData] == stylePtr) {
+	  *bp++ = elemPtr->bars[i];
+	  *ip++ = iData;
 	}
-	free(elemPtr->bars);
-	free(elemPtr->barToData);
-	elemPtr->bars = bars;
-	elemPtr->barToData = barToData;
+      }
+      stylePtr->nBars = bp - stylePtr->bars;
     }
+    free(elemPtr->bars);
+    free(elemPtr->barToData);
+    elemPtr->bars = bars;
+    elemPtr->barToData = barToData;
+  }
 
-    if (elemPtr->xeb.length > 0) {
-	Blt_ChainLink link;
-	Segment2d *bars, *sp;
-	int *map, *ip;
-
-	bars = malloc(elemPtr->xeb.length * sizeof(Segment2d));
-	map = malloc(elemPtr->xeb.length * sizeof(int));
-	sp = bars, ip = map;
-	for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
-	     link != NULL; link = Blt_Chain_NextLink(link)) {
-	    BarStyle *stylePtr;
-	    int i;
-
-	    stylePtr = Blt_Chain_GetValue(link);
-	    stylePtr->xeb.segments = sp;
-	    for (i = 0; i < elemPtr->xeb.length; i++) {
-		int iData;
-
-		iData = elemPtr->xeb.map[i];
-		if (dataToStyle[iData] == stylePtr) {
-		    *sp++ = elemPtr->xeb.segments[i];
-		    *ip++ = iData;
-		}
-	    }
-	    stylePtr->xeb.length = sp - stylePtr->xeb.segments;
+  if (elemPtr->xeb.length > 0) {
+    Blt_ChainLink link;
+    Segment2d *bars, *sp;
+    int *map, *ip;
+
+    bars = malloc(elemPtr->xeb.length * sizeof(Segment2d));
+    map = malloc(elemPtr->xeb.length * sizeof(int));
+    sp = bars, ip = map;
+    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
+	 link != NULL; link = Blt_Chain_NextLink(link)) {
+      BarStyle *stylePtr;
+      int i;
+
+      stylePtr = Blt_Chain_GetValue(link);
+      stylePtr->xeb.segments = sp;
+      for (i = 0; i < elemPtr->xeb.length; i++) {
+	int iData;
+
+	iData = elemPtr->xeb.map[i];
+	if (dataToStyle[iData] == stylePtr) {
+	  *sp++ = elemPtr->xeb.segments[i];
+	  *ip++ = iData;
 	}
-	free(elemPtr->xeb.segments);
-	elemPtr->xeb.segments = bars;
-	free(elemPtr->xeb.map);
-	elemPtr->xeb.map = map;
-    }
-    if (elemPtr->yeb.length > 0) {
-	Blt_ChainLink link;
-	Segment2d *bars, *sp;
-	int *map, *ip;
-
-	bars = malloc(elemPtr->yeb.length * sizeof(Segment2d));
-	map = malloc(elemPtr->yeb.length * sizeof(int));
-	sp = bars, ip = map;
-	for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; 
-	     link = Blt_Chain_NextLink(link)) {
-	    BarStyle *stylePtr;
-	    int i;
-
-	    stylePtr = Blt_Chain_GetValue(link);
-	    stylePtr->yeb.segments = sp;
-	    for (i = 0; i < elemPtr->yeb.length; i++) {
-		int iData;
-
-		iData = elemPtr->yeb.map[i];
-		if (dataToStyle[iData] == stylePtr) {
-		    *sp++ = elemPtr->yeb.segments[i];
-		    *ip++ = iData;
-		}
-	    }
-	    stylePtr->yeb.length = sp - stylePtr->yeb.segments;
+      }
+      stylePtr->xeb.length = sp - stylePtr->xeb.segments;
+    }
+    free(elemPtr->xeb.segments);
+    elemPtr->xeb.segments = bars;
+    free(elemPtr->xeb.map);
+    elemPtr->xeb.map = map;
+  }
+  if (elemPtr->yeb.length > 0) {
+    Blt_ChainLink link;
+    Segment2d *bars, *sp;
+    int *map, *ip;
+
+    bars = malloc(elemPtr->yeb.length * sizeof(Segment2d));
+    map = malloc(elemPtr->yeb.length * sizeof(int));
+    sp = bars, ip = map;
+    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; 
+	 link = Blt_Chain_NextLink(link)) {
+      BarStyle *stylePtr;
+      int i;
+
+      stylePtr = Blt_Chain_GetValue(link);
+      stylePtr->yeb.segments = sp;
+      for (i = 0; i < elemPtr->yeb.length; i++) {
+	int iData;
+
+	iData = elemPtr->yeb.map[i];
+	if (dataToStyle[iData] == stylePtr) {
+	  *sp++ = elemPtr->yeb.segments[i];
+	  *ip++ = iData;
 	}
-	free(elemPtr->yeb.segments);
-	elemPtr->yeb.segments = bars;
-	free(elemPtr->yeb.map);
-	elemPtr->yeb.map = map;
-    }
+      }
+      stylePtr->yeb.length = sp - stylePtr->yeb.segments;
+    }
+    free(elemPtr->yeb.segments);
+    elemPtr->yeb.segments = bars;
+    free(elemPtr->yeb.map);
+    elemPtr->yeb.map = map;
+  }
 }
 
 /*
@@ -1039,84 +1019,83 @@ MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
  *
  *---------------------------------------------------------------------------
  */
-static void
-MapActiveBars(BarElement *elemPtr)
+
+static void MapActiveBars(BarElement *elemPtr)
 {
-    if (elemPtr->activeRects != NULL) {
-	free(elemPtr->activeRects);
-	elemPtr->activeRects = NULL;
-    }
-    if (elemPtr->activeToData != NULL) {
-	free(elemPtr->activeToData);
-	elemPtr->activeToData = NULL;
-    }
-    elemPtr->nActive = 0;
+  if (elemPtr->activeRects != NULL) {
+    free(elemPtr->activeRects);
+    elemPtr->activeRects = NULL;
+  }
+  if (elemPtr->activeToData != NULL) {
+    free(elemPtr->activeToData);
+    elemPtr->activeToData = NULL;
+  }
+  elemPtr->nActive = 0;
+
+  if (elemPtr->nActiveIndices > 0) {
+    XRectangle *activeRects;
+    int *activeToData;
+    int i;
+    int count;
 
-    if (elemPtr->nActiveIndices > 0) {
-	XRectangle *activeRects;
-	int *activeToData;
-	int i;
-	int count;
-
-	activeRects = malloc(sizeof(XRectangle) * 
-				       elemPtr->nActiveIndices);
-	activeToData = malloc(sizeof(int) * 
-					elemPtr->nActiveIndices);
-	count = 0;
-	for (i = 0; i < elemPtr->nBars; i++) {
-	    int *ip, *iend;
-
-	    for (ip = elemPtr->activeIndices, 
-		     iend = ip + elemPtr->nActiveIndices; ip < iend; ip++) {
-		if (elemPtr->barToData[i] == *ip) {
-		    activeRects[count] = elemPtr->bars[i];
-		    activeToData[count] = i;
-		    count++;
-		}
-	    }
+    activeRects = malloc(sizeof(XRectangle) * 
+			 elemPtr->nActiveIndices);
+    activeToData = malloc(sizeof(int) * 
+			  elemPtr->nActiveIndices);
+    count = 0;
+    for (i = 0; i < elemPtr->nBars; i++) {
+      int *ip, *iend;
+
+      for (ip = elemPtr->activeIndices, 
+	     iend = ip + elemPtr->nActiveIndices; ip < iend; ip++) {
+	if (elemPtr->barToData[i] == *ip) {
+	  activeRects[count] = elemPtr->bars[i];
+	  activeToData[count] = i;
+	  count++;
 	}
-	elemPtr->nActive = count;
-	elemPtr->activeRects = activeRects;
-	elemPtr->activeToData = activeToData;
+      }
     }
-    elemPtr->flags &= ~ACTIVE_PENDING;
+    elemPtr->nActive = count;
+    elemPtr->activeRects = activeRects;
+    elemPtr->activeToData = activeToData;
+  }
+  elemPtr->flags &= ~ACTIVE_PENDING;
 }
 
-static void
-ResetBar(BarElement *elemPtr)
+static void ResetBar(BarElement *elemPtr)
 {
-    /* Release any storage associated with the display of the bar */
-    ResetStylePalette(elemPtr->stylePalette);
-    if (elemPtr->activeRects != NULL) {
-	free(elemPtr->activeRects);
-    }
-    if (elemPtr->activeToData != NULL) {
-	free(elemPtr->activeToData);
-    }
-    if (elemPtr->xeb.segments != NULL) {
-	free(elemPtr->xeb.segments);
-    }
-    if (elemPtr->xeb.map != NULL) {
-	free(elemPtr->xeb.map);
-    }
-    if (elemPtr->yeb.segments != NULL) {
-	free(elemPtr->yeb.segments);
-    }
-    if (elemPtr->yeb.map != NULL) {
-	free(elemPtr->yeb.map);
-    }
-    if (elemPtr->bars != NULL) {
-	free(elemPtr->bars);
-    }
-    if (elemPtr->barToData != NULL) {
-	free(elemPtr->barToData);
-    }
-    elemPtr->activeToData = elemPtr->xeb.map = elemPtr->yeb.map = 
-	elemPtr->barToData = NULL;
-    elemPtr->activeRects = elemPtr->bars = NULL;
-    elemPtr->xeb.segments = elemPtr->yeb.segments = NULL;
-    elemPtr->nActive = elemPtr->xeb.length = elemPtr->yeb.length = 
-	elemPtr->nBars = 0;
+  /* Release any storage associated with the display of the bar */
+  ResetStylePalette(elemPtr->stylePalette);
+  if (elemPtr->activeRects != NULL) {
+    free(elemPtr->activeRects);
+  }
+  if (elemPtr->activeToData != NULL) {
+    free(elemPtr->activeToData);
+  }
+  if (elemPtr->xeb.segments != NULL) {
+    free(elemPtr->xeb.segments);
+  }
+  if (elemPtr->xeb.map != NULL) {
+    free(elemPtr->xeb.map);
+  }
+  if (elemPtr->yeb.segments != NULL) {
+    free(elemPtr->yeb.segments);
+  }
+  if (elemPtr->yeb.map != NULL) {
+    free(elemPtr->yeb.map);
+  }
+  if (elemPtr->bars != NULL) {
+    free(elemPtr->bars);
+  }
+  if (elemPtr->barToData != NULL) {
+    free(elemPtr->barToData);
+  }
+  elemPtr->activeToData = elemPtr->xeb.map = elemPtr->yeb.map = 
+    elemPtr->barToData = NULL;
+  elemPtr->activeRects = elemPtr->bars = NULL;
+  elemPtr->xeb.segments = elemPtr->yeb.segments = NULL;
+  elemPtr->nActive = elemPtr->xeb.length = elemPtr->yeb.length = 
+    elemPtr->nBars = 0;
 }
 
 /*
@@ -1135,142 +1114,142 @@ ResetBar(BarElement *elemPtr)
  *
  *---------------------------------------------------------------------------
  */
-static void
-MapErrorBars(Graph *graphPtr, BarElement *elemPtr, BarStyle **dataToStyle)
+static void MapErrorBars(Graph *graphPtr, BarElement *elemPtr, 
+			 BarStyle **dataToStyle)
 {
-    int n, nPoints;
-    Region2d reg;
-
-    Blt_GraphExtents(graphPtr, &reg);
-    nPoints = NUMBEROFPOINTS(elemPtr);
-    if (elemPtr->xError.nValues > 0) {
-	n = MIN(elemPtr->xError.nValues, nPoints);
-    } else {
-	n = MIN3(elemPtr->xHigh.nValues, elemPtr->xLow.nValues, nPoints);
-    }
-    if (n > 0) {
-	Segment2d *bars;
-	Segment2d *segPtr;
-	int *map;
-	int *indexPtr;
-	int i;
+  int n, nPoints;
+  Region2d reg;
+
+  Blt_GraphExtents(graphPtr, &reg);
+  nPoints = NUMBEROFPOINTS(elemPtr);
+  if (elemPtr->xError.nValues > 0) {
+    n = MIN(elemPtr->xError.nValues, nPoints);
+  } else {
+    n = MIN3(elemPtr->xHigh.nValues, elemPtr->xLow.nValues, nPoints);
+  }
+  if (n > 0) {
+    Segment2d *bars;
+    Segment2d *segPtr;
+    int *map;
+    int *indexPtr;
+    int i;
 		
-	segPtr = bars = malloc(n * 3 * sizeof(Segment2d));
-	indexPtr = map = malloc(n * 3 * sizeof(int));
-	for (i = 0; i < n; i++) {
-	    double x, y;
-	    double high, low;
-	    BarStyle *stylePtr;
-
-	    x = elemPtr->x.values[i];
-	    y = elemPtr->y.values[i];
-	    stylePtr = dataToStyle[i];
-	    if ((isfinite(x)) && (isfinite(y))) {
-		if (elemPtr->xError.nValues > 0) {
-		    high = x + elemPtr->xError.values[i];
-		    low = x - elemPtr->xError.values[i];
-		} else {
-		    high = elemPtr->xHigh.values[i];
-		    low = elemPtr->xLow.values[i];
-		}
-		if ((isfinite(high)) && (isfinite(low)))  {
-		    Point2d p, q;
-
-		    p = Blt_Map2D(graphPtr, high, y, &elemPtr->axes);
-		    q = Blt_Map2D(graphPtr, low, y, &elemPtr->axes);
-		    segPtr->p = p;
-		    segPtr->q = q;
-		    if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
-			segPtr++;
-			*indexPtr++ = i;
-		    }
-		    /* Left cap */
-		    segPtr->p.x = segPtr->q.x = p.x;
-		    segPtr->p.y = p.y - stylePtr->errorBarCapWidth;
-		    segPtr->q.y = p.y + stylePtr->errorBarCapWidth;
-		    if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
-			segPtr++;
-			*indexPtr++ = i;
-		    }
-		    /* Right cap */
-		    segPtr->p.x = segPtr->q.x = q.x;
-		    segPtr->p.y = q.y - stylePtr->errorBarCapWidth;
-		    segPtr->q.y = q.y + stylePtr->errorBarCapWidth;
-		    if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
-			segPtr++;
-			*indexPtr++ = i;
-		    }
-		}
-	    }
+    segPtr = bars = malloc(n * 3 * sizeof(Segment2d));
+    indexPtr = map = malloc(n * 3 * sizeof(int));
+    for (i = 0; i < n; i++) {
+      double x, y;
+      double high, low;
+      BarStyle *stylePtr;
+
+      x = elemPtr->x.values[i];
+      y = elemPtr->y.values[i];
+      stylePtr = dataToStyle[i];
+      if ((isfinite(x)) && (isfinite(y))) {
+	if (elemPtr->xError.nValues > 0) {
+	  high = x + elemPtr->xError.values[i];
+	  low = x - elemPtr->xError.values[i];
+	} else {
+	  high = elemPtr->xHigh.values[i];
+	  low = elemPtr->xLow.values[i];
 	}
-	elemPtr->xeb.segments = bars;
-	elemPtr->xeb.length = segPtr - bars;
-	elemPtr->xeb.map = map;
-    }
-    if (elemPtr->yError.nValues > 0) {
-	n = MIN(elemPtr->yError.nValues, nPoints);
-    } else {
-	n = MIN3(elemPtr->yHigh.nValues, elemPtr->yLow.nValues, nPoints);
-    }
-    if (n > 0) {
-	Segment2d *bars;
-	Segment2d *segPtr;
-	int *map;
-	int *indexPtr;
-	int i;
+	if ((isfinite(high)) && (isfinite(low)))  {
+	  Point2d p, q;
+
+	  p = Blt_Map2D(graphPtr, high, y, &elemPtr->axes);
+	  q = Blt_Map2D(graphPtr, low, y, &elemPtr->axes);
+	  segPtr->p = p;
+	  segPtr->q = q;
+	  if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = i;
+	  }
+	  /* Left cap */
+	  segPtr->p.x = segPtr->q.x = p.x;
+	  segPtr->p.y = p.y - stylePtr->errorBarCapWidth;
+	  segPtr->q.y = p.y + stylePtr->errorBarCapWidth;
+	  if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = i;
+	  }
+	  /* Right cap */
+	  segPtr->p.x = segPtr->q.x = q.x;
+	  segPtr->p.y = q.y - stylePtr->errorBarCapWidth;
+	  segPtr->q.y = q.y + stylePtr->errorBarCapWidth;
+	  if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = i;
+	  }
+	}
+      }
+    }
+    elemPtr->xeb.segments = bars;
+    elemPtr->xeb.length = segPtr - bars;
+    elemPtr->xeb.map = map;
+  }
+  if (elemPtr->yError.nValues > 0) {
+    n = MIN(elemPtr->yError.nValues, nPoints);
+  } else {
+    n = MIN3(elemPtr->yHigh.nValues, elemPtr->yLow.nValues, nPoints);
+  }
+  if (n > 0) {
+    Segment2d *bars;
+    Segment2d *segPtr;
+    int *map;
+    int *indexPtr;
+    int i;
 		
-	segPtr = bars = malloc(n * 3 * sizeof(Segment2d));
-	indexPtr = map = malloc(n * 3 * sizeof(int));
-	for (i = 0; i < n; i++) {
-	    double x, y;
-	    double high, low;
-	    BarStyle *stylePtr;
-
-	    x = elemPtr->x.values[i];
-	    y = elemPtr->y.values[i];
-	    stylePtr = dataToStyle[i];
-	    if ((isfinite(x)) && (isfinite(y))) {
-		if (elemPtr->yError.nValues > 0) {
-		    high = y + elemPtr->yError.values[i];
-		    low = y - elemPtr->yError.values[i];
-		} else {
-		    high = elemPtr->yHigh.values[i];
-		    low = elemPtr->yLow.values[i];
-		}
-		if ((isfinite(high)) && (isfinite(low)))  {
-		    Point2d p, q;
+    segPtr = bars = malloc(n * 3 * sizeof(Segment2d));
+    indexPtr = map = malloc(n * 3 * sizeof(int));
+    for (i = 0; i < n; i++) {
+      double x, y;
+      double high, low;
+      BarStyle *stylePtr;
+
+      x = elemPtr->x.values[i];
+      y = elemPtr->y.values[i];
+      stylePtr = dataToStyle[i];
+      if ((isfinite(x)) && (isfinite(y))) {
+	if (elemPtr->yError.nValues > 0) {
+	  high = y + elemPtr->yError.values[i];
+	  low = y - elemPtr->yError.values[i];
+	} else {
+	  high = elemPtr->yHigh.values[i];
+	  low = elemPtr->yLow.values[i];
+	}
+	if ((isfinite(high)) && (isfinite(low)))  {
+	  Point2d p, q;
 		    
-		    p = Blt_Map2D(graphPtr, x, high, &elemPtr->axes);
-		    q = Blt_Map2D(graphPtr, x, low, &elemPtr->axes);
-		    segPtr->p = p;
-		    segPtr->q = q;
-		    if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
-			segPtr++;
-			*indexPtr++ = i;
-		    }
-		    /* Top cap. */
-		    segPtr->p.y = segPtr->q.y = p.y;
-		    segPtr->p.x = p.x - stylePtr->errorBarCapWidth;
-		    segPtr->q.x = p.x + stylePtr->errorBarCapWidth;
-		    if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
-			segPtr++;
-			*indexPtr++ = i;
-		    }
-		    /* Bottom cap. */
-		    segPtr->p.y = segPtr->q.y = q.y;
-		    segPtr->p.x = q.x - stylePtr->errorBarCapWidth;
-		    segPtr->q.x = q.x + stylePtr->errorBarCapWidth;
-		    if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
-			segPtr++;
-			*indexPtr++ = i;
-		    }
-		}
-	    }
+	  p = Blt_Map2D(graphPtr, x, high, &elemPtr->axes);
+	  q = Blt_Map2D(graphPtr, x, low, &elemPtr->axes);
+	  segPtr->p = p;
+	  segPtr->q = q;
+	  if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = i;
+	  }
+	  /* Top cap. */
+	  segPtr->p.y = segPtr->q.y = p.y;
+	  segPtr->p.x = p.x - stylePtr->errorBarCapWidth;
+	  segPtr->q.x = p.x + stylePtr->errorBarCapWidth;
+	  if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = i;
+	  }
+	  /* Bottom cap. */
+	  segPtr->p.y = segPtr->q.y = q.y;
+	  segPtr->p.x = q.x - stylePtr->errorBarCapWidth;
+	  segPtr->q.x = q.x + stylePtr->errorBarCapWidth;
+	  if (Blt_LineRectClip(&reg, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = i;
+	  }
 	}
-	elemPtr->yeb.segments = bars;
-	elemPtr->yeb.length = segPtr - bars;
-	elemPtr->yeb.map = map;
+      }
     }
+    elemPtr->yeb.segments = bars;
+    elemPtr->yeb.length = segPtr - bars;
+    elemPtr->yeb.map = map;
+  }
 }
 
 
@@ -1296,238 +1275,238 @@ MapErrorBars(Graph *graphPtr, BarElement *elemPtr, BarStyle **dataToStyle)
  *
  *---------------------------------------------------------------------------
  */
-static void
-MapBarProc(Graph *graphPtr, Element *basePtr)
+
+static void MapBarProc(Graph *graphPtr, Element *basePtr)
 {
-    BarElement *elemPtr = (BarElement *)basePtr;
-    BarStyle **dataToStyle;
-    double *x, *y;
-    double barWidth, barOffset;
-    double baseline, ybot;
-    int *barToData;			/* Maps bars to data point indices */
-    int invertBar;
-    int nPoints, count;
-    XRectangle *rp, *bars;
-    int i;
-    int size;
+  BarElement *elemPtr = (BarElement *)basePtr;
+  BarStyle **dataToStyle;
+  double *x, *y;
+  double barWidth, barOffset;
+  double baseline, ybot;
+  int *barToData;			/* Maps bars to data point indices */
+  int invertBar;
+  int nPoints, count;
+  XRectangle *rp, *bars;
+  int i;
+  int size;
+
+  ResetBar(elemPtr);
+  nPoints = NUMBEROFPOINTS(elemPtr);
+  if (nPoints < 1) {
+    return;				/* No data points */
+  }
+  barWidth = graphPtr->barWidth;
+  barWidth = (elemPtr->barWidth > 0.0f) 
+    ? elemPtr->barWidth : graphPtr->barWidth;
+  baseline = (elemPtr->axes.y->logScale) ? 0.0 : graphPtr->baseline;
+  barOffset = barWidth * 0.5;
+
+  /*
+   * Create an array of bars representing the screen coordinates of all the
+   * segments in the bar.
+   */
+  bars = calloc(nPoints, sizeof(XRectangle));
+  barToData = calloc(nPoints, sizeof(int));
+
+  x = elemPtr->x.values, y = elemPtr->y.values;
+  count = 0;
+  for (rp = bars, i = 0; i < nPoints; i++) {
+    Point2d c1, c2;			/* Two opposite corners of the rectangle
+					 * in graph coordinates. */
+    double dx, dy;
+    int height;
+    double right, left, top, bottom;
 
-    ResetBar(elemPtr);
-    nPoints = NUMBEROFPOINTS(elemPtr);
-    if (nPoints < 1) {
-	return;				/* No data points */
+    if (((x[i] - barWidth) > elemPtr->axes.x->axisRange.max) ||
+	((x[i] + barWidth) < elemPtr->axes.x->axisRange.min)) {
+      continue;			/* Abscissa is out of range of the
+				 * x-axis */
     }
-    barWidth = graphPtr->barWidth;
-    barWidth = (elemPtr->barWidth > 0.0f) 
-	? elemPtr->barWidth : graphPtr->barWidth;
-    baseline = (elemPtr->axes.y->logScale) ? 0.0 : graphPtr->baseline;
-    barOffset = barWidth * 0.5;
+    c1.x = x[i] - barOffset;
+    c1.y = y[i];
+    c2.x = c1.x + barWidth;
+    c2.y = baseline;
 
     /*
-     * Create an array of bars representing the screen coordinates of all the
-     * segments in the bar.
+     * If the mode is "aligned" or "stacked" we need to adjust the x or y
+     * coordinates of the two corners.
      */
-    bars = calloc(nPoints, sizeof(XRectangle));
-    barToData = calloc(nPoints, sizeof(int));
 
-    x = elemPtr->x.values, y = elemPtr->y.values;
-    count = 0;
-    for (rp = bars, i = 0; i < nPoints; i++) {
-	Point2d c1, c2;			/* Two opposite corners of the rectangle
-					 * in graph coordinates. */
-	double dx, dy;
-	int height;
-	double right, left, top, bottom;
-
-	if (((x[i] - barWidth) > elemPtr->axes.x->axisRange.max) ||
-	    ((x[i] + barWidth) < elemPtr->axes.x->axisRange.min)) {
-	    continue;			/* Abscissa is out of range of the
-					 * x-axis */
-	}
-	c1.x = x[i] - barOffset;
-	c1.y = y[i];
-	c2.x = c1.x + barWidth;
-	c2.y = baseline;
-
-	/*
-	 * If the mode is "aligned" or "stacked" we need to adjust the x or y
-	 * coordinates of the two corners.
-	 */
-
-	if ((graphPtr->nBarGroups > 0) && (graphPtr->mode != BARS_INFRONT) && 
-	    (!graphPtr->stackAxes)) {
-	    Tcl_HashEntry *hPtr;
-	    BarSetKey key;
-
-	    key.value = (float)x[i];
-	    key.axes = elemPtr->axes;
-	    key.axes.y = NULL;
-	    hPtr = Tcl_FindHashEntry(&graphPtr->setTable, (char *)&key);
-	    if (hPtr != NULL) {
-		Tcl_HashTable *tablePtr;
-		const char *name;
-
-		tablePtr = Tcl_GetHashValue(hPtr);
-		name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
-		    elemPtr->axes.y->obj.name;
- 		hPtr = Tcl_FindHashEntry(tablePtr, name);
-		if (hPtr != NULL) {
-		    BarGroup *groupPtr;
-		    double slice, width, offset;
+    if ((graphPtr->nBarGroups > 0) && (graphPtr->mode != BARS_INFRONT) && 
+	(!graphPtr->stackAxes)) {
+      Tcl_HashEntry *hPtr;
+      BarSetKey key;
+
+      key.value = (float)x[i];
+      key.axes = elemPtr->axes;
+      key.axes.y = NULL;
+      hPtr = Tcl_FindHashEntry(&graphPtr->setTable, (char *)&key);
+      if (hPtr != NULL) {
+	Tcl_HashTable *tablePtr;
+	const char *name;
+
+	tablePtr = Tcl_GetHashValue(hPtr);
+	name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
+	  elemPtr->axes.y->obj.name;
+	hPtr = Tcl_FindHashEntry(tablePtr, name);
+	if (hPtr != NULL) {
+	  BarGroup *groupPtr;
+	  double slice, width, offset;
 		    
-		    groupPtr = Tcl_GetHashValue(hPtr);
-		    slice = barWidth / (double)graphPtr->maxBarSetSize;
-		    offset = (slice * groupPtr->index);
-		    if (graphPtr->maxBarSetSize > 1) {
-			offset += slice * 0.05;
-			slice *= 0.90;
-		    }
-		    switch (graphPtr->mode) {
-		    case BARS_STACKED:
-			groupPtr->count++;
-			c2.y = groupPtr->lastY;
-			c1.y += c2.y;
-			groupPtr->lastY = c1.y;
-			c1.x += offset;
-			c2.x = c1.x + slice;
-			break;
+	  groupPtr = Tcl_GetHashValue(hPtr);
+	  slice = barWidth / (double)graphPtr->maxBarSetSize;
+	  offset = (slice * groupPtr->index);
+	  if (graphPtr->maxBarSetSize > 1) {
+	    offset += slice * 0.05;
+	    slice *= 0.90;
+	  }
+	  switch (graphPtr->mode) {
+	  case BARS_STACKED:
+	    groupPtr->count++;
+	    c2.y = groupPtr->lastY;
+	    c1.y += c2.y;
+	    groupPtr->lastY = c1.y;
+	    c1.x += offset;
+	    c2.x = c1.x + slice;
+	    break;
 			
-		    case BARS_ALIGNED:
-			slice /= groupPtr->nSegments;
-			c1.x += offset + (slice * groupPtr->count);
-			c2.x = c1.x + slice;
-			groupPtr->count++;
-			break;
+	  case BARS_ALIGNED:
+	    slice /= groupPtr->nSegments;
+	    c1.x += offset + (slice * groupPtr->count);
+	    c2.x = c1.x + slice;
+	    groupPtr->count++;
+	    break;
 			
-		    case BARS_OVERLAP:
-			slice /= (groupPtr->nSegments + 1);
-			width = slice + slice;
-			groupPtr->count++;
-			c1.x += offset + 
-			    (slice * (groupPtr->nSegments - groupPtr->count));
-			c2.x = c1.x + width;
-			break;
+	  case BARS_OVERLAP:
+	    slice /= (groupPtr->nSegments + 1);
+	    width = slice + slice;
+	    groupPtr->count++;
+	    c1.x += offset + 
+	      (slice * (groupPtr->nSegments - groupPtr->count));
+	    c2.x = c1.x + width;
+	    break;
 			
-		    case BARS_INFRONT:
-			break;
-		    }
-		}
-	    }
+	  case BARS_INFRONT:
+	    break;
+	  }
 	}
-	invertBar = FALSE;
-	if (c1.y < c2.y) {
-	    double temp;
+      }
+    }
+    invertBar = FALSE;
+    if (c1.y < c2.y) {
+      double temp;
 
-	    /* Handle negative bar values by swapping ordinates */
-	    temp = c1.y, c1.y = c2.y, c2.y = temp;
-	    invertBar = TRUE;
-	}
-	/*
-	 * Get the two corners of the bar segment and compute the rectangle
-	 */
-	ybot = c2.y;
-	c1 = Blt_Map2D(graphPtr, c1.x, c1.y, &elemPtr->axes);
-	c2 = Blt_Map2D(graphPtr, c2.x, c2.y, &elemPtr->axes);
-	if ((ybot == 0.0) && (elemPtr->axes.y->logScale)) {
-	    c2.y = graphPtr->bottom;
-	}
+      /* Handle negative bar values by swapping ordinates */
+      temp = c1.y, c1.y = c2.y, c2.y = temp;
+      invertBar = TRUE;
+    }
+    /*
+     * Get the two corners of the bar segment and compute the rectangle
+     */
+    ybot = c2.y;
+    c1 = Blt_Map2D(graphPtr, c1.x, c1.y, &elemPtr->axes);
+    c2 = Blt_Map2D(graphPtr, c2.x, c2.y, &elemPtr->axes);
+    if ((ybot == 0.0) && (elemPtr->axes.y->logScale)) {
+      c2.y = graphPtr->bottom;
+    }
 	    
-	if (c2.y < c1.y) {
-	    double t;
-	    t = c1.y, c1.y = c2.y, c2.y = t;
-	}
-	if (c2.x < c1.x) {
-	    double t;
-	    t = c1.x, c1.x = c2.x, c2.x = t;
-	}
-	if ((c1.x > graphPtr->right) || (c2.x < graphPtr->left) || 
-	    (c1.y > graphPtr->bottom) || (c2.y < graphPtr->top)) {
-	    continue;
-	}
-	/* Bound the bars horizontally by the width of the graph window */
-	/* Bound the bars vertically by the position of the axis. */
-	if (graphPtr->stackAxes) {
-	    top = elemPtr->axes.y->screenMin;
-	    bottom = elemPtr->axes.y->screenMin + elemPtr->axes.y->screenRange;
-	    left = graphPtr->left;
-	    right = graphPtr->right;
-	} else {
-	    left = top = 0;
-	    bottom = right = 10000;
-	    /* Shouldn't really have a call to Tk_Width or Tk_Height in
-	     * mapping routine.  We only want to clamp the bar segment to the
-	     * size of the window if we're actually mapped onscreen. */
-	    if (Tk_Height(graphPtr->tkwin) > 1) {
-		bottom = Tk_Height(graphPtr->tkwin);
-	    }
-	    if (Tk_Width(graphPtr->tkwin) > 1) {
-		right = Tk_Width(graphPtr->tkwin);
-	    }
-	}
-	CLAMP(c1.y, top, bottom);
-	CLAMP(c2.y, top, bottom);
-	CLAMP(c1.x, left, right);
-	CLAMP(c2.x, left, right);
-	dx = fabs(c1.x - c2.x);
-	dy = fabs(c1.y - c2.y);
-	if ((dx == 0) || (dy == 0)) {
-	    continue;
-	}
-	height = (int)dy;
-	if (invertBar) {
-	    rp->y = (short int)MIN(c1.y, c2.y);
-	} else {
-	    rp->y = (short int)(MAX(c1.y, c2.y)) - height;
-	}
-	rp->x = (short int)MIN(c1.x, c2.x);
-	rp->width = (short int)dx + 1;
-	rp->width |= 0x1;
-	if (rp->width < 1) {
-	    rp->width = 1;
-	}
-	rp->height = height + 1;
-	if (rp->height < 1) {
-	    rp->height = 1;
-	}
-	barToData[count] = i;		/* Save the data index corresponding to
-					 * the rectangle */
-	count++;
-	rp++;
+    if (c2.y < c1.y) {
+      double t;
+      t = c1.y, c1.y = c2.y, c2.y = t;
+    }
+    if (c2.x < c1.x) {
+      double t;
+      t = c1.x, c1.x = c2.x, c2.x = t;
+    }
+    if ((c1.x > graphPtr->right) || (c2.x < graphPtr->left) || 
+	(c1.y > graphPtr->bottom) || (c2.y < graphPtr->top)) {
+      continue;
+    }
+    /* Bound the bars horizontally by the width of the graph window */
+    /* Bound the bars vertically by the position of the axis. */
+    if (graphPtr->stackAxes) {
+      top = elemPtr->axes.y->screenMin;
+      bottom = elemPtr->axes.y->screenMin + elemPtr->axes.y->screenRange;
+      left = graphPtr->left;
+      right = graphPtr->right;
+    } else {
+      left = top = 0;
+      bottom = right = 10000;
+      /* Shouldn't really have a call to Tk_Width or Tk_Height in
+       * mapping routine.  We only want to clamp the bar segment to the
+       * size of the window if we're actually mapped onscreen. */
+      if (Tk_Height(graphPtr->tkwin) > 1) {
+	bottom = Tk_Height(graphPtr->tkwin);
+      }
+      if (Tk_Width(graphPtr->tkwin) > 1) {
+	right = Tk_Width(graphPtr->tkwin);
+      }
+    }
+    CLAMP(c1.y, top, bottom);
+    CLAMP(c2.y, top, bottom);
+    CLAMP(c1.x, left, right);
+    CLAMP(c2.x, left, right);
+    dx = fabs(c1.x - c2.x);
+    dy = fabs(c1.y - c2.y);
+    if ((dx == 0) || (dy == 0)) {
+      continue;
+    }
+    height = (int)dy;
+    if (invertBar) {
+      rp->y = (short int)MIN(c1.y, c2.y);
+    } else {
+      rp->y = (short int)(MAX(c1.y, c2.y)) - height;
     }
-    elemPtr->nBars = count;
-    elemPtr->bars = bars;
-    elemPtr->barToData = barToData;
-    if (elemPtr->nActiveIndices > 0) {
-	MapActiveBars(elemPtr);
+    rp->x = (short int)MIN(c1.x, c2.x);
+    rp->width = (short int)dx + 1;
+    rp->width |= 0x1;
+    if (rp->width < 1) {
+      rp->width = 1;
     }
-	
-    size = 20;
-    if (count > 0) {
-	size = bars->width;
+    rp->height = height + 1;
+    if (rp->height < 1) {
+      rp->height = 1;
     }
-    {
-	Blt_ChainLink link;
+    barToData[count] = i;		/* Save the data index corresponding to
+					 * the rectangle */
+    count++;
+    rp++;
+  }
+  elemPtr->nBars = count;
+  elemPtr->bars = bars;
+  elemPtr->barToData = barToData;
+  if (elemPtr->nActiveIndices > 0) {
+    MapActiveBars(elemPtr);
+  }
+	
+  size = 20;
+  if (count > 0) {
+    size = bars->width;
+  }
+  {
+    Blt_ChainLink link;
 
-	/* Set the symbol size of all the pen styles. */
-	for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL;
-	     link = Blt_Chain_NextLink(link)) {
-	    BarStyle *stylePtr;
+    /* Set the symbol size of all the pen styles. */
+    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL;
+	 link = Blt_Chain_NextLink(link)) {
+      BarStyle *stylePtr;
 	    
-	    stylePtr = Blt_Chain_GetValue(link);
-	    stylePtr->symbolSize = size;
-	    stylePtr->errorBarCapWidth = 
-		(stylePtr->penPtr->errorBarCapWidth > 0) 
-		? stylePtr->penPtr->errorBarCapWidth : (size * 66666) / 100000;
-	    stylePtr->errorBarCapWidth /= 2;
-	}
-    }
-    dataToStyle = (BarStyle **)Blt_StyleMap((Element *)elemPtr);
-    if (((elemPtr->yHigh.nValues > 0) && (elemPtr->yLow.nValues > 0)) ||
-	((elemPtr->xHigh.nValues > 0) && (elemPtr->xLow.nValues > 0)) ||
-	(elemPtr->xError.nValues > 0) || (elemPtr->yError.nValues > 0)) {
-	MapErrorBars(graphPtr, elemPtr, dataToStyle);
-    }
-    MergePens(elemPtr, dataToStyle);
-    free(dataToStyle);
+      stylePtr = Blt_Chain_GetValue(link);
+      stylePtr->symbolSize = size;
+      stylePtr->errorBarCapWidth = 
+	(stylePtr->penPtr->errorBarCapWidth > 0) 
+	? stylePtr->penPtr->errorBarCapWidth : (size * 66666) / 100000;
+      stylePtr->errorBarCapWidth /= 2;
+    }
+  }
+  dataToStyle = (BarStyle **)Blt_StyleMap((Element *)elemPtr);
+  if (((elemPtr->yHigh.nValues > 0) && (elemPtr->yLow.nValues > 0)) ||
+      ((elemPtr->xHigh.nValues > 0) && (elemPtr->xLow.nValues > 0)) ||
+      (elemPtr->xError.nValues > 0) || (elemPtr->yError.nValues > 0)) {
+    MapErrorBars(graphPtr, elemPtr, dataToStyle);
+  }
+  MergePens(elemPtr, dataToStyle);
+  free(dataToStyle);
 }
 
 /*
@@ -1546,39 +1525,38 @@ MapBarProc(Graph *graphPtr, Element *basePtr)
  *	centered position of the symbol.  
  *---------------------------------------------------------------------------
  */
-/*ARGSUSED*/
-static void
-DrawSymbolProc(Graph *graphPtr, Drawable drawable, Element *basePtr, 
-	       int x, int y, int size)
-{
-    BarElement *elemPtr = (BarElement *)basePtr;
-    BarPen *penPtr;
-    int radius;
 
-    penPtr = NORMALPEN(elemPtr);
-    if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) {
-	return;
-    }
-    radius = (size / 2);
-    size--;
-
-    x -= radius;
-    y -= radius;
-    if (penPtr->fillGC != NULL) {
-	XSetTSOrigin(graphPtr->display, penPtr->fillGC, x, y);
-    }
-    if (penPtr->stipple != None) {
-	XFillRectangle(graphPtr->display, drawable, penPtr->fillGC, x, y, 
-		       size, size);
-    } else {
-	Tk_Fill3DRectangle(graphPtr->tkwin, drawable, penPtr->fill, 
-		x, y, size, size, penPtr->borderWidth, penPtr->relief);
-    }
-    XDrawRectangle(graphPtr->display, drawable, penPtr->outlineGC, x, y, 
+static void DrawSymbolProc(Graph *graphPtr, Drawable drawable, 
+			   Element *basePtr, int x, int y, int size)
+{
+  BarElement *elemPtr = (BarElement *)basePtr;
+  BarPen *penPtr;
+  int radius;
+
+  penPtr = NORMALPEN(elemPtr);
+  if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) {
+    return;
+  }
+  radius = (size / 2);
+  size--;
+
+  x -= radius;
+  y -= radius;
+  if (penPtr->fillGC != NULL) {
+    XSetTSOrigin(graphPtr->display, penPtr->fillGC, x, y);
+  }
+  if (penPtr->stipple != None) {
+    XFillRectangle(graphPtr->display, drawable, penPtr->fillGC, x, y, 
 		   size, size);
-    if (penPtr->fillGC != NULL) {
-	XSetTSOrigin(graphPtr->display, penPtr->fillGC, 0, 0);
-    }
+  } else {
+    Tk_Fill3DRectangle(graphPtr->tkwin, drawable, penPtr->fill, 
+		       x, y, size, size, penPtr->borderWidth, penPtr->relief);
+  }
+  XDrawRectangle(graphPtr->display, drawable, penPtr->outlineGC, x, y, 
+		 size, size);
+  if (penPtr->fillGC != NULL) {
+    XSetTSOrigin(graphPtr->display, penPtr->fillGC, 0, 0);
+  }
 }
 
 static void SetBackgroundClipRegion(Tk_Window tkwin, Tk_3DBorder border, 
@@ -1622,64 +1600,65 @@ static void UnsetBackgroundClipRegion(Tk_Window tkwin, Tk_3DBorder border)
  *
  *---------------------------------------------------------------------------
  */
+
 static void DrawBarSegments(Graph *graphPtr, Drawable drawable, BarPen *penPtr,
 			    XRectangle *bars, int nBars)
 {
-    TkRegion rgn;
-
-    {
-	XRectangle clip;
-	clip.x = graphPtr->left;
-	clip.y = graphPtr->top;
-	clip.width  = graphPtr->right - graphPtr->left + 1;
-	clip.height = graphPtr->bottom - graphPtr->top + 1;
-	rgn = TkCreateRegion();
-	TkUnionRectWithRegion(&clip, rgn, rgn);
+  TkRegion rgn;
+
+  {
+    XRectangle clip;
+    clip.x = graphPtr->left;
+    clip.y = graphPtr->top;
+    clip.width  = graphPtr->right - graphPtr->left + 1;
+    clip.height = graphPtr->bottom - graphPtr->top + 1;
+    rgn = TkCreateRegion();
+    TkUnionRectWithRegion(&clip, rgn, rgn);
+  }
+  if (penPtr->fill != NULL) {
+    XRectangle *rp, *rend;
+    int hasOutline;
+    int relief;
+
+    relief = (penPtr->relief == TK_RELIEF_SOLID) 
+      ? TK_RELIEF_FLAT: penPtr->relief;
+    hasOutline = ((relief == TK_RELIEF_FLAT) && 
+		  (penPtr->outlineColor != NULL));
+    if (penPtr->stipple != None) {
+      TkSetRegion(graphPtr->display, penPtr->fillGC, rgn);
     }
-    if (penPtr->fill != NULL) {
-	XRectangle *rp, *rend;
-	int hasOutline;
-	int relief;
-
-	relief = (penPtr->relief == TK_RELIEF_SOLID) 
-	    ? TK_RELIEF_FLAT: penPtr->relief;
-	hasOutline = ((relief == TK_RELIEF_FLAT) && 
-		      (penPtr->outlineColor != NULL));
-	if (penPtr->stipple != None) {
-	    TkSetRegion(graphPtr->display, penPtr->fillGC, rgn);
-	}
-	SetBackgroundClipRegion(graphPtr->tkwin, penPtr->fill, rgn);
-	if (hasOutline) {
-	    TkSetRegion(graphPtr->display, penPtr->outlineGC, rgn);
-	}
-	for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
-	    if (penPtr->stipple != None) {
-		XFillRectangle(graphPtr->display, drawable, penPtr->fillGC, 
-			       rp->x, rp->y, rp->width, rp->height);
-	    } else {
-		Tk_Fill3DRectangle(graphPtr->tkwin, drawable, 
-			penPtr->fill, rp->x, rp->y, rp->width, rp->height, 
-			penPtr->borderWidth, relief);
-	    }
-	    if (hasOutline) {
-		XDrawRectangle(graphPtr->display, drawable, penPtr->outlineGC, 
-			       rp->x, rp->y, rp->width, rp->height);
-	    }
-	}
-	UnsetBackgroundClipRegion(graphPtr->tkwin, penPtr->fill);
-	if (hasOutline) {
-	    XSetClipMask(graphPtr->display, penPtr->outlineGC, None);
-	}
-	if (penPtr->stipple != None) {
-	    XSetClipMask(graphPtr->display, penPtr->fillGC, None);
-	}
-    } else if (penPtr->outlineColor != NULL) {
-	TkSetRegion(graphPtr->display, penPtr->outlineGC, rgn);
-	XDrawRectangles(graphPtr->display, drawable, penPtr->outlineGC, bars, 
-			nBars);
-	XSetClipMask(graphPtr->display, penPtr->outlineGC, None);
+    SetBackgroundClipRegion(graphPtr->tkwin, penPtr->fill, rgn);
+    if (hasOutline) {
+      TkSetRegion(graphPtr->display, penPtr->outlineGC, rgn);
     }
-    TkDestroyRegion(rgn);
+    for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
+      if (penPtr->stipple != None) {
+	XFillRectangle(graphPtr->display, drawable, penPtr->fillGC, 
+		       rp->x, rp->y, rp->width, rp->height);
+      } else {
+	Tk_Fill3DRectangle(graphPtr->tkwin, drawable, 
+			   penPtr->fill, rp->x, rp->y, rp->width, rp->height, 
+			   penPtr->borderWidth, relief);
+      }
+      if (hasOutline) {
+	XDrawRectangle(graphPtr->display, drawable, penPtr->outlineGC, 
+		       rp->x, rp->y, rp->width, rp->height);
+      }
+    }
+    UnsetBackgroundClipRegion(graphPtr->tkwin, penPtr->fill);
+    if (hasOutline) {
+      XSetClipMask(graphPtr->display, penPtr->outlineGC, None);
+    }
+    if (penPtr->stipple != None) {
+      XSetClipMask(graphPtr->display, penPtr->fillGC, None);
+    }
+  } else if (penPtr->outlineColor != NULL) {
+    TkSetRegion(graphPtr->display, penPtr->outlineGC, rgn);
+    XDrawRectangles(graphPtr->display, drawable, penPtr->outlineGC, bars, 
+		    nBars);
+    XSetClipMask(graphPtr->display, penPtr->outlineGC, None);
+  }
+  TkDestroyRegion(rgn);
 }
 
 /*
@@ -1694,53 +1673,54 @@ static void DrawBarSegments(Graph *graphPtr, Drawable drawable, BarPen *penPtr,
  *
  *---------------------------------------------------------------------------
  */
-static void
-DrawBarValues(Graph *graphPtr, Drawable drawable, BarElement *elemPtr,
-	      BarPen *penPtr, XRectangle *bars, int nBars, int *barToData)
+static void DrawBarValues(Graph *graphPtr, Drawable drawable, 
+			  BarElement *elemPtr,
+			  BarPen *penPtr, XRectangle *bars, int nBars, 
+			  int *barToData)
 {
-    XRectangle *rp, *rend;
-    int count;
-    const char *fmt;
+  XRectangle *rp, *rend;
+  int count;
+  const char *fmt;
     
-    fmt = penPtr->valueFormat;
-    if (fmt == NULL) {
-	fmt = "%g";
-    }
-    count = 0;
-    for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
-	Point2d anchorPos;
-	double x, y;
-	char string[TCL_DOUBLE_SPACE * 2 + 2];
-
-	x = elemPtr->x.values[barToData[count]];
-	y = elemPtr->y.values[barToData[count]];
+  fmt = penPtr->valueFormat;
+  if (fmt == NULL) {
+    fmt = "%g";
+  }
+  count = 0;
+  for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
+    Point2d anchorPos;
+    double x, y;
+    char string[TCL_DOUBLE_SPACE * 2 + 2];
 
-	count++;
-	if (penPtr->valueShow == SHOW_X) {
-	    sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); 
-	} else if (penPtr->valueShow == SHOW_Y) {
-	    sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); 
-	} else if (penPtr->valueShow == SHOW_BOTH) {
-	    sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x);
-	    strcat(string, ",");
-	    sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
-	}
-	if (graphPtr->inverted) {
-	    anchorPos.y = rp->y + rp->height * 0.5;
-	    anchorPos.x = rp->x + rp->width;
-	    if (x < graphPtr->baseline) {
-		anchorPos.x -= rp->width;
-	    } 
-	} else {
-	    anchorPos.x = rp->x + rp->width * 0.5;
-	    anchorPos.y = rp->y;
-	    if (y < graphPtr->baseline) {			
-		anchorPos.y += rp->height;
-	    }
-	}
-	Blt_DrawText(graphPtr->tkwin, drawable, string, &penPtr->valueStyle, 
-		     (int)anchorPos.x, (int)anchorPos.y);
-    }
+    x = elemPtr->x.values[barToData[count]];
+    y = elemPtr->y.values[barToData[count]];
+
+    count++;
+    if (penPtr->valueShow == SHOW_X) {
+      sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); 
+    } else if (penPtr->valueShow == SHOW_Y) {
+      sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); 
+    } else if (penPtr->valueShow == SHOW_BOTH) {
+      sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x);
+      strcat(string, ",");
+      sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
+    }
+    if (graphPtr->inverted) {
+      anchorPos.y = rp->y + rp->height * 0.5;
+      anchorPos.x = rp->x + rp->width;
+      if (x < graphPtr->baseline) {
+	anchorPos.x -= rp->width;
+      } 
+    } else {
+      anchorPos.x = rp->x + rp->width * 0.5;
+      anchorPos.y = rp->y;
+      if (y < graphPtr->baseline) {			
+	anchorPos.y += rp->height;
+      }
+    }
+    Blt_DrawText(graphPtr->tkwin, drawable, string, &penPtr->valueStyle, 
+		 (int)anchorPos.x, (int)anchorPos.y);
+  }
 }
 
 
@@ -1764,40 +1744,41 @@ DrawBarValues(Graph *graphPtr, Drawable drawable, BarElement *elemPtr,
  *
  *---------------------------------------------------------------------------
  */
-static void
-DrawNormalBarProc(Graph *graphPtr, Drawable drawable, Element *basePtr)
+
+static void DrawNormalBarProc(Graph *graphPtr, Drawable drawable, 
+			      Element *basePtr)
 {
-    BarElement *elemPtr = (BarElement *)basePtr;
-    int count;
-    Blt_ChainLink link;
+  BarElement *elemPtr = (BarElement *)basePtr;
+  int count;
+  Blt_ChainLink link;
 
-    count = 0;
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL;
-	 link = Blt_Chain_NextLink(link)) {
-	BarStyle *stylePtr;
-	BarPen *penPtr;
-
-	stylePtr = Blt_Chain_GetValue(link);
-	penPtr = stylePtr->penPtr;
-	if (stylePtr->nBars > 0) {
-	    DrawBarSegments(graphPtr, drawable, penPtr, stylePtr->bars,
-		stylePtr->nBars);
-	}
-	if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) {
-	    Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, 
-		       stylePtr->xeb.segments, stylePtr->xeb.length);
-	}
-	if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) {
-	    Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, 
-		       stylePtr->yeb.segments, stylePtr->yeb.length);
-	}
-	if (penPtr->valueShow != SHOW_NONE) {
-	    DrawBarValues(graphPtr, drawable, elemPtr, penPtr, 
-			stylePtr->bars, stylePtr->nBars, 
-			elemPtr->barToData + count);
-	}
-	count += stylePtr->nBars;
-    }
+  count = 0;
+  for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL;
+       link = Blt_Chain_NextLink(link)) {
+    BarStyle *stylePtr;
+    BarPen *penPtr;
+
+    stylePtr = Blt_Chain_GetValue(link);
+    penPtr = stylePtr->penPtr;
+    if (stylePtr->nBars > 0) {
+      DrawBarSegments(graphPtr, drawable, penPtr, stylePtr->bars,
+		      stylePtr->nBars);
+    }
+    if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) {
+      Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, 
+			 stylePtr->xeb.segments, stylePtr->xeb.length);
+    }
+    if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) {
+      Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, 
+			 stylePtr->yeb.segments, stylePtr->yeb.length);
+    }
+    if (penPtr->valueShow != SHOW_NONE) {
+      DrawBarValues(graphPtr, drawable, elemPtr, penPtr, 
+		    stylePtr->bars, stylePtr->nBars, 
+		    elemPtr->barToData + count);
+    }
+    count += stylePtr->nBars;
+  }
 }
 
 /*
@@ -1817,34 +1798,35 @@ DrawNormalBarProc(Graph *graphPtr, Drawable drawable, Element *basePtr)
  *
  *---------------------------------------------------------------------------
  */
-static void
-DrawActiveBarProc(Graph *graphPtr, Drawable drawable, Element *basePtr)
+
+static void DrawActiveBarProc(Graph *graphPtr, Drawable drawable, 
+			      Element *basePtr)
 {
-    BarElement *elemPtr = (BarElement *)basePtr;
-
-    if (elemPtr->activePenPtr != NULL) {
-	BarPen *penPtr = elemPtr->activePenPtr;
-
-	if (elemPtr->nActiveIndices > 0) {
-	    if (elemPtr->flags & ACTIVE_PENDING) {
-		MapActiveBars(elemPtr);
-	    }
-	    DrawBarSegments(graphPtr, drawable, penPtr, elemPtr->activeRects, 
-			 elemPtr->nActive);
-	    if (penPtr->valueShow != SHOW_NONE) {
-		DrawBarValues(graphPtr, drawable, elemPtr, penPtr, 
-			elemPtr->activeRects, elemPtr->nActive, 
-			elemPtr->activeToData);
-	    }
-	} else if (elemPtr->nActiveIndices < 0) {
-	    DrawBarSegments(graphPtr, drawable, penPtr, elemPtr->bars, 
-			 elemPtr->nBars);
-	    if (penPtr->valueShow != SHOW_NONE) {
-		DrawBarValues(graphPtr, drawable, elemPtr, penPtr, 
-			elemPtr->bars, elemPtr->nBars, elemPtr->barToData);
-	    }
-	}
-    }
+  BarElement *elemPtr = (BarElement *)basePtr;
+
+  if (elemPtr->activePenPtr != NULL) {
+    BarPen *penPtr = elemPtr->activePenPtr;
+
+    if (elemPtr->nActiveIndices > 0) {
+      if (elemPtr->flags & ACTIVE_PENDING) {
+	MapActiveBars(elemPtr);
+      }
+      DrawBarSegments(graphPtr, drawable, penPtr, elemPtr->activeRects, 
+		      elemPtr->nActive);
+      if (penPtr->valueShow != SHOW_NONE) {
+	DrawBarValues(graphPtr, drawable, elemPtr, penPtr, 
+		      elemPtr->activeRects, elemPtr->nActive, 
+		      elemPtr->activeToData);
+      }
+    } else if (elemPtr->nActiveIndices < 0) {
+      DrawBarSegments(graphPtr, drawable, penPtr, elemPtr->bars, 
+		      elemPtr->nBars);
+      if (penPtr->valueShow != SHOW_NONE) {
+	DrawBarValues(graphPtr, drawable, elemPtr, penPtr, 
+		      elemPtr->bars, elemPtr->nBars, elemPtr->barToData);
+      }
+    }
+  }
 }
 
 /*
@@ -1864,134 +1846,133 @@ DrawActiveBarProc(Graph *graphPtr, Drawable drawable, Element *basePtr)
  *
  *---------------------------------------------------------------------------
  */
-/*ARGSUSED*/
-static void
-SymbolToPostScriptProc(
-    Graph *graphPtr,
-    Blt_Ps ps,
-    Element *basePtr,
-    double x, double y,
-    int size)
-{
-    BarElement *elemPtr = (BarElement *)basePtr;
-    BarPen *penPtr;
 
-    penPtr = NORMALPEN(elemPtr);
-    if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) {
-	return;
-    }
-    /*
-     * Build a PostScript procedure to draw the fill and outline of the symbol
-     * after the path of the symbol shape has been formed
-     */
-    Blt_Ps_Append(ps, "\n"
-		  "/DrawSymbolProc {\n"
-		  "gsave\n    ");
-    if (penPtr->stipple != None) {
-	if (penPtr->fill != NULL) {
-	    Blt_Ps_XSetBackground(ps, Tk_3DBorderColor(penPtr->fill));
-	    Blt_Ps_Append(ps, "    gsave fill grestore\n    ");
-	}
-	if (penPtr->outlineColor != NULL) {
-	    Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
-	} else {
-	    Blt_Ps_XSetForeground(ps, Tk_3DBorderColor(penPtr->fill));
-	}
-	Blt_Ps_XSetStipple(ps, graphPtr->display, penPtr->stipple);
-    } else if (penPtr->outlineColor != NULL) {
-	Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
-	Blt_Ps_Append(ps, "    fill\n");
+static void SymbolToPostScriptProc(
+				   Graph *graphPtr,
+				   Blt_Ps ps,
+				   Element *basePtr,
+				   double x, double y,
+				   int size)
+{
+  BarElement *elemPtr = (BarElement *)basePtr;
+  BarPen *penPtr;
+
+  penPtr = NORMALPEN(elemPtr);
+  if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) {
+    return;
+  }
+  /*
+   * Build a PostScript procedure to draw the fill and outline of the symbol
+   * after the path of the symbol shape has been formed
+   */
+  Blt_Ps_Append(ps, "\n"
+		"/DrawSymbolProc {\n"
+		"gsave\n    ");
+  if (penPtr->stipple != None) {
+    if (penPtr->fill != NULL) {
+      Blt_Ps_XSetBackground(ps, Tk_3DBorderColor(penPtr->fill));
+      Blt_Ps_Append(ps, "    gsave fill grestore\n    ");
     }
-    Blt_Ps_Append(ps, "  grestore\n");
-    Blt_Ps_Append(ps, "} def\n\n");
-    Blt_Ps_Format(ps, "%g %g %d Sq\n", x, y, size);
+    if (penPtr->outlineColor != NULL) {
+      Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
+    } else {
+      Blt_Ps_XSetForeground(ps, Tk_3DBorderColor(penPtr->fill));
+    }
+    Blt_Ps_XSetStipple(ps, graphPtr->display, penPtr->stipple);
+  } else if (penPtr->outlineColor != NULL) {
+    Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
+    Blt_Ps_Append(ps, "    fill\n");
+  }
+  Blt_Ps_Append(ps, "  grestore\n");
+  Blt_Ps_Append(ps, "} def\n\n");
+  Blt_Ps_Format(ps, "%g %g %d Sq\n", x, y, size);
 }
 
 static void
 SegmentsToPostScript(Graph *graphPtr, Blt_Ps ps, BarPen *penPtr, 
 		     XRectangle *bars, int nBars)
 {
-    XRectangle *rp, *rend;
+  XRectangle *rp, *rend;
 
-    if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) {
-	return;
+  if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) {
+    return;
+  }
+  for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
+    if ((rp->width < 1) || (rp->height < 1)) {
+      continue;
     }
-    for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
-	if ((rp->width < 1) || (rp->height < 1)) {
-	    continue;
-	}
-	if (penPtr->stipple != None) {
-	    Blt_Ps_Rectangle(ps, rp->x, rp->y, rp->width - 1, rp->height - 1);
-	    if (penPtr->fill != NULL) {
-		Blt_Ps_XSetBackground(ps, Tk_3DBorderColor(penPtr->fill));
-		Blt_Ps_Append(ps, "gsave fill grestore\n");
-	    }
-	    if (penPtr->outlineColor != NULL) {
-		Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
-	    } else {
-		Blt_Ps_XSetForeground(ps, Tk_3DBorderColor(penPtr->fill));
-	    }
-	    Blt_Ps_XSetStipple(ps, graphPtr->display, penPtr->stipple);
-	} else if (penPtr->outlineColor != NULL) {
-	    Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
-	    Blt_Ps_XFillRectangle(ps, (double)rp->x, (double)rp->y, 
-		(int)rp->width - 1, (int)rp->height - 1);
-	}
-	if ((penPtr->fill != NULL) && (penPtr->borderWidth > 0) && 
-	    (penPtr->relief != TK_RELIEF_FLAT)) {
-	    Blt_Ps_Draw3DRectangle(ps, penPtr->fill, 
-		(double)rp->x, (double)rp->y, (int)rp->width, (int)rp->height,
-		penPtr->borderWidth, penPtr->relief);
-	}
+    if (penPtr->stipple != None) {
+      Blt_Ps_Rectangle(ps, rp->x, rp->y, rp->width - 1, rp->height - 1);
+      if (penPtr->fill != NULL) {
+	Blt_Ps_XSetBackground(ps, Tk_3DBorderColor(penPtr->fill));
+	Blt_Ps_Append(ps, "gsave fill grestore\n");
+      }
+      if (penPtr->outlineColor != NULL) {
+	Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
+      } else {
+	Blt_Ps_XSetForeground(ps, Tk_3DBorderColor(penPtr->fill));
+      }
+      Blt_Ps_XSetStipple(ps, graphPtr->display, penPtr->stipple);
+    } else if (penPtr->outlineColor != NULL) {
+      Blt_Ps_XSetForeground(ps, penPtr->outlineColor);
+      Blt_Ps_XFillRectangle(ps, (double)rp->x, (double)rp->y, 
+			    (int)rp->width - 1, (int)rp->height - 1);
     }
+    if ((penPtr->fill != NULL) && (penPtr->borderWidth > 0) && 
+	(penPtr->relief != TK_RELIEF_FLAT)) {
+      Blt_Ps_Draw3DRectangle(ps, penPtr->fill, 
+			     (double)rp->x, (double)rp->y, (int)rp->width, (int)rp->height,
+			     penPtr->borderWidth, penPtr->relief);
+    }
+  }
 }
 
-static void
-BarValuesToPostScript(Graph *graphPtr, Blt_Ps ps, BarElement *elemPtr,
-		      BarPen *penPtr, XRectangle *bars, int nBars, 
-		      int *barToData)
+static void BarValuesToPostScript(Graph *graphPtr, Blt_Ps ps, 
+				  BarElement *elemPtr,
+				  BarPen *penPtr, XRectangle *bars, int nBars, 
+				  int *barToData)
 {
-    XRectangle *rp, *rend;
-    int count;
-    const char *fmt;
-    char string[TCL_DOUBLE_SPACE * 2 + 2];
-    double x, y;
-    Point2d anchorPos;
+  XRectangle *rp, *rend;
+  int count;
+  const char *fmt;
+  char string[TCL_DOUBLE_SPACE * 2 + 2];
+  double x, y;
+  Point2d anchorPos;
     
-    count = 0;
-    fmt = penPtr->valueFormat;
-    if (fmt == NULL) {
-	fmt = "%g";
-    }
-    for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
-	x = elemPtr->x.values[barToData[count]];
-	y = elemPtr->y.values[barToData[count]];
-	count++;
-	if (penPtr->valueShow == SHOW_X) {
-	    sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); 
-	} else if (penPtr->valueShow == SHOW_Y) {
-	    sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); 
-	} else if (penPtr->valueShow == SHOW_BOTH) {
-	    sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x);
-	    strcat(string, ",");
-	    sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
-	}
-	if (graphPtr->inverted) {
-	    anchorPos.y = rp->y + rp->height * 0.5;
-	    anchorPos.x = rp->x + rp->width;
-	    if (x < graphPtr->baseline) {
-		anchorPos.x -= rp->width;
-	    } 
-	} else {
-	    anchorPos.x = rp->x + rp->width * 0.5;
-	    anchorPos.y = rp->y;
-	    if (y < graphPtr->baseline) {			
-		anchorPos.y += rp->height;
-	    }
-	}
-	Blt_Ps_DrawText(ps, string, &penPtr->valueStyle, anchorPos.x, 
-		anchorPos.y);
-    }
+  count = 0;
+  fmt = penPtr->valueFormat;
+  if (fmt == NULL) {
+    fmt = "%g";
+  }
+  for (rp = bars, rend = rp + nBars; rp < rend; rp++) {
+    x = elemPtr->x.values[barToData[count]];
+    y = elemPtr->y.values[barToData[count]];
+    count++;
+    if (penPtr->valueShow == SHOW_X) {
+      sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); 
+    } else if (penPtr->valueShow == SHOW_Y) {
+      sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); 
+    } else if (penPtr->valueShow == SHOW_BOTH) {
+      sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x);
+      strcat(string, ",");
+      sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
+    }
+    if (graphPtr->inverted) {
+      anchorPos.y = rp->y + rp->height * 0.5;
+      anchorPos.x = rp->x + rp->width;
+      if (x < graphPtr->baseline) {
+	anchorPos.x -= rp->width;
+      } 
+    } else {
+      anchorPos.x = rp->x + rp->width * 0.5;
+      anchorPos.y = rp->y;
+      if (y < graphPtr->baseline) {			
+	anchorPos.y += rp->height;
+      }
+    }
+    Blt_Ps_DrawText(ps, string, &penPtr->valueStyle, anchorPos.x, 
+		    anchorPos.y);
+  }
 }
 
 /*
@@ -2011,34 +1992,34 @@ BarValuesToPostScript(Graph *graphPtr, Blt_Ps ps, BarElement *elemPtr,
  *
  *---------------------------------------------------------------------------
  */
-/*ARGSUSED*/
-static void
-ActiveBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr)
+
+static void ActiveBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, 
+				      Element *basePtr)
 {
-    BarElement *elemPtr = (BarElement *)basePtr;
+  BarElement *elemPtr = (BarElement *)basePtr;
 
-    if (elemPtr->activePenPtr != NULL) {
-	BarPen *penPtr = elemPtr->activePenPtr;
+  if (elemPtr->activePenPtr != NULL) {
+    BarPen *penPtr = elemPtr->activePenPtr;
 	
-	if (elemPtr->nActiveIndices > 0) {
-	    if (elemPtr->flags & ACTIVE_PENDING) {
-		MapActiveBars(elemPtr);
-	    }
-	    SegmentsToPostScript(graphPtr, ps, penPtr, elemPtr->activeRects,
-		elemPtr->nActive);
-	    if (penPtr->valueShow != SHOW_NONE) {
-		BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, 
-		   elemPtr->activeRects, elemPtr->nActive, elemPtr->activeToData);
-	    }
-	} else if (elemPtr->nActiveIndices < 0) {
-	    SegmentsToPostScript(graphPtr, ps, penPtr, elemPtr->bars, 
-		elemPtr->nBars);
-	    if (penPtr->valueShow != SHOW_NONE) {
-		BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, 
-		   elemPtr->bars, elemPtr->nBars, elemPtr->barToData);
-	    }
-	}
-    }
+    if (elemPtr->nActiveIndices > 0) {
+      if (elemPtr->flags & ACTIVE_PENDING) {
+	MapActiveBars(elemPtr);
+      }
+      SegmentsToPostScript(graphPtr, ps, penPtr, elemPtr->activeRects,
+			   elemPtr->nActive);
+      if (penPtr->valueShow != SHOW_NONE) {
+	BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, 
+			      elemPtr->activeRects, elemPtr->nActive, elemPtr->activeToData);
+      }
+    } else if (elemPtr->nActiveIndices < 0) {
+      SegmentsToPostScript(graphPtr, ps, penPtr, elemPtr->bars, 
+			   elemPtr->nBars);
+      if (penPtr->valueShow != SHOW_NONE) {
+	BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, 
+			      elemPtr->bars, elemPtr->nBars, elemPtr->barToData);
+      }
+    }
+  }
 }
 
 /*
@@ -2057,49 +2038,49 @@ ActiveBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr)
  *
  *---------------------------------------------------------------------------
  */
-/*ARGSUSED*/
-static void
-NormalBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr)
+
+static void NormalBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, 
+				      Element *basePtr)
 {
-    BarElement *elemPtr = (BarElement *)basePtr;
-    Blt_ChainLink link;
-    int count;
+  BarElement *elemPtr = (BarElement *)basePtr;
+  Blt_ChainLink link;
+  int count;
 
-    count = 0;
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL;
-	 link = Blt_Chain_NextLink(link)) {
-	BarStyle *stylePtr;
-	BarPen *penPtr;
-	XColor *colorPtr;
-
-	stylePtr = Blt_Chain_GetValue(link);
-	penPtr = stylePtr->penPtr;
-	if (stylePtr->nBars > 0) {
-	    SegmentsToPostScript(graphPtr, ps, penPtr, stylePtr->bars, 
-		stylePtr->nBars);
-	}
-	colorPtr = penPtr->errorBarColor;
-	if (colorPtr == COLOR_DEFAULT) {
-	    colorPtr = penPtr->outlineColor;
-	}
-	if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) {
-	    Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, 
-		NULL, CapButt, JoinMiter);
-	    Blt_Ps_Draw2DSegments(ps, stylePtr->xeb.segments,
-		stylePtr->xeb.length);
-	}
-	if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) {
-	    Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, 
-		NULL, CapButt, JoinMiter);
-	    Blt_Ps_Draw2DSegments(ps, stylePtr->yeb.segments, 
-		stylePtr->yeb.length);
-	}
-	if (penPtr->valueShow != SHOW_NONE) {
-	    BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, 
-		stylePtr->bars, stylePtr->nBars, elemPtr->barToData + count);
-	}
-	count += stylePtr->nBars;
-    }
+  count = 0;
+  for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL;
+       link = Blt_Chain_NextLink(link)) {
+    BarStyle *stylePtr;
+    BarPen *penPtr;
+    XColor *colorPtr;
+
+    stylePtr = Blt_Chain_GetValue(link);
+    penPtr = stylePtr->penPtr;
+    if (stylePtr->nBars > 0) {
+      SegmentsToPostScript(graphPtr, ps, penPtr, stylePtr->bars, 
+			   stylePtr->nBars);
+    }
+    colorPtr = penPtr->errorBarColor;
+    if (colorPtr == COLOR_DEFAULT) {
+      colorPtr = penPtr->outlineColor;
+    }
+    if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) {
+      Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, 
+				NULL, CapButt, JoinMiter);
+      Blt_Ps_Draw2DSegments(ps, stylePtr->xeb.segments,
+			    stylePtr->xeb.length);
+    }
+    if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) {
+      Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, 
+				NULL, CapButt, JoinMiter);
+      Blt_Ps_Draw2DSegments(ps, stylePtr->yeb.segments, 
+			    stylePtr->yeb.length);
+    }
+    if (penPtr->valueShow != SHOW_NONE) {
+      BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, 
+			    stylePtr->bars, stylePtr->nBars, elemPtr->barToData + count);
+    }
+    count += stylePtr->nBars;
+  }
 }
 
 /*
@@ -2118,23 +2099,22 @@ NormalBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr)
  *---------------------------------------------------------------------------
  */
 
-static void
-DestroyBarProc(Graph *graphPtr, Element *basePtr)
+static void DestroyBarProc(Graph *graphPtr, Element *basePtr)
 {
-    BarElement *elemPtr = (BarElement *)basePtr;
-
-    DestroyBarPen(graphPtr, elemPtr->builtinPenPtr);
-    if (elemPtr->activePenPtr != NULL) {
-	Blt_FreePen((Pen *)elemPtr->activePenPtr);
-    }
-    ResetBar(elemPtr);
-    if (elemPtr->stylePalette != NULL) {
-	Blt_FreeStylePalette(elemPtr->stylePalette);
-	Blt_Chain_Destroy(elemPtr->stylePalette);
-    }
-    if (elemPtr->activeIndices != NULL) {
-	free(elemPtr->activeIndices);
-    }
+  BarElement *elemPtr = (BarElement *)basePtr;
+
+  DestroyBarPen(graphPtr, elemPtr->builtinPenPtr);
+  if (elemPtr->activePenPtr != NULL) {
+    Blt_FreePen((Pen *)elemPtr->activePenPtr);
+  }
+  ResetBar(elemPtr);
+  if (elemPtr->stylePalette != NULL) {
+    Blt_FreeStylePalette(elemPtr->stylePalette);
+    Blt_Chain_Destroy(elemPtr->stylePalette);
+  }
+  if (elemPtr->activeIndices != NULL) {
+    free(elemPtr->activeIndices);
+  }
 }
 
 /*
@@ -2154,39 +2134,37 @@ DestroyBarProc(Graph *graphPtr, Element *basePtr)
  */
 
 static ElementProcs barProcs = {
-    ClosestBarProc,
-    ConfigureBarProc,
-    DestroyBarProc,
-    DrawActiveBarProc,
-    DrawNormalBarProc,
-    DrawSymbolProc,
-    GetBarExtentsProc,
-    ActiveBarToPostScriptProc,
-    NormalBarToPostScriptProc,
-    SymbolToPostScriptProc,
-    MapBarProc,
+  ClosestBarProc,
+  ConfigureBarProc,
+  DestroyBarProc,
+  DrawActiveBarProc,
+  DrawNormalBarProc,
+  DrawSymbolProc,
+  GetBarExtentsProc,
+  ActiveBarToPostScriptProc,
+  NormalBarToPostScriptProc,
+  SymbolToPostScriptProc,
+  MapBarProc,
 };
 
-
-Element *
-Blt_BarElement(Graph *graphPtr, const char *name, ClassId classId)
+Element* Blt_BarElement(Graph *graphPtr, const char *name, ClassId classId)
 {
-    BarElement *elemPtr;
-
-    elemPtr = calloc(1, sizeof(BarElement));
-    elemPtr->procsPtr = &barProcs;
-    elemPtr->configSpecs = barElemConfigSpecs;
-    elemPtr->legendRelief = TK_RELIEF_FLAT;
-    Blt_GraphSetObjectClass(&elemPtr->obj, classId);
-    elemPtr->obj.name = Blt_Strdup(name);
-    elemPtr->obj.graphPtr = graphPtr;
-    /* By default, an element's name and label are the same. */
-    elemPtr->label = Blt_Strdup(name);
-    elemPtr->builtinPenPtr = &elemPtr->builtinPen;
-    InitializeBarPen(elemPtr->builtinPenPtr);
-    elemPtr->stylePalette = Blt_Chain_Create();
-    bltBarStylesOption.clientData = (ClientData)sizeof(BarStyle);
-    return (Element *)elemPtr;
+  BarElement *elemPtr;
+
+  elemPtr = calloc(1, sizeof(BarElement));
+  elemPtr->procsPtr = &barProcs;
+  elemPtr->configSpecs = barElemConfigSpecs;
+  elemPtr->legendRelief = TK_RELIEF_FLAT;
+  Blt_GraphSetObjectClass(&elemPtr->obj, classId);
+  elemPtr->obj.name = Blt_Strdup(name);
+  elemPtr->obj.graphPtr = graphPtr;
+  /* By default, an element's name and label are the same. */
+  elemPtr->label = Blt_Strdup(name);
+  elemPtr->builtinPenPtr = &elemPtr->builtinPen;
+  InitializeBarPen(elemPtr->builtinPenPtr);
+  elemPtr->stylePalette = Blt_Chain_Create();
+  bltBarStylesOption.clientData = (ClientData)sizeof(BarStyle);
+  return (Element *)elemPtr;
 }
 
 /*
@@ -2207,131 +2185,131 @@ Blt_BarElement(Graph *graphPtr, const char *name, ClassId classId)
  *
  *---------------------------------------------------------------------------
  */
-void
-Blt_InitBarSetTable(Graph *graphPtr)
-{
-    Blt_ChainLink link;
-    int nStacks, nSegs;
-    Tcl_HashTable setTable;
-    int sum, max;
-    Tcl_HashEntry *hPtr;
-    Tcl_HashSearch iter;
 
-    /*
-     * Free resources associated with a previous frequency table. This includes
-     * the array of frequency information and the table itself
-     */
-    Blt_DestroyBarSets(graphPtr);
-    if (graphPtr->mode == BARS_INFRONT) {
-	return;				/* No set table is needed for
+void Blt_InitBarSetTable(Graph *graphPtr)
+{
+  Blt_ChainLink link;
+  int nStacks, nSegs;
+  Tcl_HashTable setTable;
+  int sum, max;
+  Tcl_HashEntry *hPtr;
+  Tcl_HashSearch iter;
+
+  /*
+   * Free resources associated with a previous frequency table. This includes
+   * the array of frequency information and the table itself
+   */
+  Blt_DestroyBarSets(graphPtr);
+  if (graphPtr->mode == BARS_INFRONT) {
+    return;				/* No set table is needed for
 					 * "infront" mode */
-    }
-    Tcl_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
+  }
+  Tcl_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
+
+  /*
+   * Initialize a hash table and fill it with unique abscissas.  Keep track
+   * of the frequency of each x-coordinate and how many abscissas have
+   * duplicate mappings.
+   */
+  Tcl_InitHashTable(&setTable, sizeof(BarSetKey) / sizeof(int));
+  nSegs = nStacks = 0;
+  for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList);
+       link != NULL; link = Blt_Chain_NextLink(link)) {
+    BarElement *elemPtr;
+    double *x, *xend;
+    int nPoints;
 
-    /*
-     * Initialize a hash table and fill it with unique abscissas.  Keep track
-     * of the frequency of each x-coordinate and how many abscissas have
-     * duplicate mappings.
-     */
-    Tcl_InitHashTable(&setTable, sizeof(BarSetKey) / sizeof(int));
-    nSegs = nStacks = 0;
-    for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList);
-	link != NULL; link = Blt_Chain_NextLink(link)) {
-	BarElement *elemPtr;
-	double *x, *xend;
-	int nPoints;
-
-	elemPtr = Blt_Chain_GetValue(link);
-	if ((elemPtr->flags & HIDE) || (elemPtr->obj.classId != CID_ELEM_BAR)) {
-	    continue;
-	}
-	nSegs++;
-	nPoints = NUMBEROFPOINTS(elemPtr);
-	for (x = elemPtr->x.values, xend = x + nPoints; x < xend; x++) {
-	    Tcl_HashEntry *hPtr;
-	    Tcl_HashTable *tablePtr;
-	    BarSetKey key;
-	    int isNew;
-	    size_t count;
-	    const char *name;
-
-	    key.value = *x;
-	    key.axes = elemPtr->axes;
-	    key.axes.y = NULL;
-	    hPtr = Tcl_CreateHashEntry(&setTable, (char *)&key, &isNew);
-	    if (isNew) {
-		tablePtr = malloc(sizeof(Tcl_HashTable));
-		Tcl_InitHashTable(tablePtr, TCL_STRING_KEYS);
-		Tcl_SetHashValue(hPtr, tablePtr);
-	    } else {
-		tablePtr = Tcl_GetHashValue(hPtr);
-	    }
-	    name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
-		elemPtr->axes.y->obj.name;
-	    hPtr = Tcl_CreateHashEntry(tablePtr, name, &isNew);
-	    if (isNew) {
-		count = 1;
-	    } else {
-		count = (size_t)Tcl_GetHashValue(hPtr);
- 		count++;
-	    }		
-	    Tcl_SetHashValue(hPtr, (ClientData)count);
-	}
+    elemPtr = Blt_Chain_GetValue(link);
+    if ((elemPtr->flags & HIDE) || (elemPtr->obj.classId != CID_ELEM_BAR)) {
+      continue;
     }
-    if (setTable.numEntries == 0) {
-	return;				/* No bar elements to be displayed */
-    }
-    sum = max = 0;
-    for (hPtr = Tcl_FirstHashEntry(&setTable, &iter); hPtr != NULL;
-	 hPtr = Tcl_NextHashEntry(&iter)) {
-	Tcl_HashTable *tablePtr;
-	Tcl_HashEntry *hPtr2;
-	BarSetKey *keyPtr;
-	int isNew;
-
-	keyPtr = (BarSetKey *)Tcl_GetHashKey(&setTable, hPtr);
-	hPtr2 = Tcl_CreateHashEntry(&graphPtr->setTable, (char *)keyPtr,&isNew);
+    nSegs++;
+    nPoints = NUMBEROFPOINTS(elemPtr);
+    for (x = elemPtr->x.values, xend = x + nPoints; x < xend; x++) {
+      Tcl_HashEntry *hPtr;
+      Tcl_HashTable *tablePtr;
+      BarSetKey key;
+      int isNew;
+      size_t count;
+      const char *name;
+
+      key.value = *x;
+      key.axes = elemPtr->axes;
+      key.axes.y = NULL;
+      hPtr = Tcl_CreateHashEntry(&setTable, (char *)&key, &isNew);
+      if (isNew) {
+	tablePtr = malloc(sizeof(Tcl_HashTable));
+	Tcl_InitHashTable(tablePtr, TCL_STRING_KEYS);
+	Tcl_SetHashValue(hPtr, tablePtr);
+      } else {
 	tablePtr = Tcl_GetHashValue(hPtr);
-	Tcl_SetHashValue(hPtr2, tablePtr);
-	if (max < tablePtr->numEntries) {
-	    max = tablePtr->numEntries;	/* # of stacks in group. */
-	}
-	sum += tablePtr->numEntries;
-    }
-    Tcl_DeleteHashTable(&setTable);
-    if (sum > 0) {
-	BarGroup *groupPtr;
-	Tcl_HashEntry *hPtr;
-	Tcl_HashSearch iter;
-
-	graphPtr->barGroups = calloc(sum, sizeof(BarGroup));
-	groupPtr = graphPtr->barGroups;
-	for (hPtr = Tcl_FirstHashEntry(&graphPtr->setTable, &iter); 
-	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
-	    BarSetKey *keyPtr;
-	    Tcl_HashTable *tablePtr;
-	    Tcl_HashEntry *hPtr2;
-	    Tcl_HashSearch iter2;
-	    size_t xcount;
-
-	    tablePtr = Tcl_GetHashValue(hPtr);
-	    keyPtr = (BarSetKey *)Tcl_GetHashKey(&setTable, hPtr);
-	    xcount = 0;
-	    for (hPtr2 = Tcl_FirstHashEntry(tablePtr, &iter2); hPtr2!=NULL;
-		 hPtr2 = Tcl_NextHashEntry(&iter2)) {
-		size_t count;
-
-		count = (size_t)Tcl_GetHashValue(hPtr2);
-		groupPtr->nSegments = count;
-		groupPtr->axes = keyPtr->axes;
-		Tcl_SetHashValue(hPtr2, groupPtr);
-		groupPtr->index = xcount++;
-		groupPtr++;
-	    }
-	}
-    }
-    graphPtr->maxBarSetSize = max;
-    graphPtr->nBarGroups = sum;
+      }
+      name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
+	elemPtr->axes.y->obj.name;
+      hPtr = Tcl_CreateHashEntry(tablePtr, name, &isNew);
+      if (isNew) {
+	count = 1;
+      } else {
+	count = (size_t)Tcl_GetHashValue(hPtr);
+	count++;
+      }		
+      Tcl_SetHashValue(hPtr, (ClientData)count);
+    }
+  }
+  if (setTable.numEntries == 0) {
+    return;				/* No bar elements to be displayed */
+  }
+  sum = max = 0;
+  for (hPtr = Tcl_FirstHashEntry(&setTable, &iter); hPtr != NULL;
+       hPtr = Tcl_NextHashEntry(&iter)) {
+    Tcl_HashTable *tablePtr;
+    Tcl_HashEntry *hPtr2;
+    BarSetKey *keyPtr;
+    int isNew;
+
+    keyPtr = (BarSetKey *)Tcl_GetHashKey(&setTable, hPtr);
+    hPtr2 = Tcl_CreateHashEntry(&graphPtr->setTable, (char *)keyPtr,&isNew);
+    tablePtr = Tcl_GetHashValue(hPtr);
+    Tcl_SetHashValue(hPtr2, tablePtr);
+    if (max < tablePtr->numEntries) {
+      max = tablePtr->numEntries;	/* # of stacks in group. */
+    }
+    sum += tablePtr->numEntries;
+  }
+  Tcl_DeleteHashTable(&setTable);
+  if (sum > 0) {
+    BarGroup *groupPtr;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
+
+    graphPtr->barGroups = calloc(sum, sizeof(BarGroup));
+    groupPtr = graphPtr->barGroups;
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->setTable, &iter); 
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+      BarSetKey *keyPtr;
+      Tcl_HashTable *tablePtr;
+      Tcl_HashEntry *hPtr2;
+      Tcl_HashSearch iter2;
+      size_t xcount;
+
+      tablePtr = Tcl_GetHashValue(hPtr);
+      keyPtr = (BarSetKey *)Tcl_GetHashKey(&setTable, hPtr);
+      xcount = 0;
+      for (hPtr2 = Tcl_FirstHashEntry(tablePtr, &iter2); hPtr2!=NULL;
+	   hPtr2 = Tcl_NextHashEntry(&iter2)) {
+	size_t count;
+
+	count = (size_t)Tcl_GetHashValue(hPtr2);
+	groupPtr->nSegments = count;
+	groupPtr->axes = keyPtr->axes;
+	Tcl_SetHashValue(hPtr2, groupPtr);
+	groupPtr->index = xcount++;
+	groupPtr++;
+      }
+    }
+  }
+  graphPtr->maxBarSetSize = max;
+  graphPtr->nBarGroups = sum;
 }
 
 /*
@@ -2356,96 +2334,93 @@ Blt_InitBarSetTable(Graph *graphPtr)
  *
  *---------------------------------------------------------------------------
  */
-void
-Blt_ComputeBarStacks(Graph *graphPtr)
+
+void Blt_ComputeBarStacks(Graph *graphPtr)
 {
-    Blt_ChainLink link;
-    printf("mode: %d groups: %d\n", graphPtr->mode, graphPtr->nBarGroups);
-    if ((graphPtr->mode != BARS_STACKED) || (graphPtr->nBarGroups == 0)) {
-	return;
-    }
+  Blt_ChainLink link;
+  if ((graphPtr->mode != BARS_STACKED) || (graphPtr->nBarGroups == 0)) {
+    return;
+  }
 
-    /* Initialize the stack sums to zero. */
-    {
-	BarGroup *gp, *gend;
+  /* Initialize the stack sums to zero. */
+  {
+    BarGroup *gp, *gend;
 
-	for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; 
-	     gp < gend; gp++) {
-	    gp->sum = 0.0;
-	}
+    for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; 
+	 gp < gend; gp++) {
+      gp->sum = 0.0;
     }
+  }
 
-    /* Consider each bar x-y coordinate. Add the ordinates of duplicate
-     * abscissas. */
-
-    for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); 
-	 link != NULL; link = Blt_Chain_NextLink(link)) {
-	BarElement *elemPtr;
-	double *x, *y, *xend;
+  /* Consider each bar x-y coordinate. Add the ordinates of duplicate
+   * abscissas. */
 
-	elemPtr = Blt_Chain_GetValue(link);
-	if ((elemPtr->flags & HIDE) || (elemPtr->obj.classId != CID_ELEM_BAR)) {
-	    continue;
-	}
-	for (x = elemPtr->x.values, y = elemPtr->y.values, 
-		 xend = x + NUMBEROFPOINTS(elemPtr); x < xend; x++, y++) {
-	    BarSetKey key;
-	    BarGroup *groupPtr;
-	    Tcl_HashEntry *hPtr;
-	    Tcl_HashTable *tablePtr;
-	    const char *name;
-
-	    key.value = *x;
-	    key.axes = elemPtr->axes;
-	    key.axes.y = NULL;
-	    hPtr = Tcl_FindHashEntry(&graphPtr->setTable, (char *)&key);
-	    if (hPtr == NULL) {
-		continue;
-	    }
-	    tablePtr = Tcl_GetHashValue(hPtr);
-	    name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
-		elemPtr->axes.y->obj.name;
-	    hPtr = Tcl_FindHashEntry(tablePtr, name);
-	    if (hPtr == NULL) {
-		continue;
-	    }
-	    groupPtr = Tcl_GetHashValue(hPtr);
-	    groupPtr->sum += *y;
-	}
-    }
+  for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); 
+       link != NULL; link = Blt_Chain_NextLink(link)) {
+    BarElement *elemPtr;
+    double *x, *y, *xend;
+
+    elemPtr = Blt_Chain_GetValue(link);
+    if ((elemPtr->flags & HIDE) || (elemPtr->obj.classId != CID_ELEM_BAR)) {
+      continue;
+    }
+    for (x = elemPtr->x.values, y = elemPtr->y.values, 
+	   xend = x + NUMBEROFPOINTS(elemPtr); x < xend; x++, y++) {
+      BarSetKey key;
+      BarGroup *groupPtr;
+      Tcl_HashEntry *hPtr;
+      Tcl_HashTable *tablePtr;
+      const char *name;
+
+      key.value = *x;
+      key.axes = elemPtr->axes;
+      key.axes.y = NULL;
+      hPtr = Tcl_FindHashEntry(&graphPtr->setTable, (char *)&key);
+      if (hPtr == NULL) {
+	continue;
+      }
+      tablePtr = Tcl_GetHashValue(hPtr);
+      name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
+	elemPtr->axes.y->obj.name;
+      hPtr = Tcl_FindHashEntry(tablePtr, name);
+      if (hPtr == NULL) {
+	continue;
+      }
+      groupPtr = Tcl_GetHashValue(hPtr);
+      groupPtr->sum += *y;
+    }
+  }
 }
 
-void
-Blt_ResetBarGroups(Graph *graphPtr)
+void Blt_ResetBarGroups(Graph *graphPtr)
 {
-    BarGroup *gp, *gend;
+  BarGroup *gp, *gend;
 
-    for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; gp < gend; 
-	 gp++) {
-	gp->lastY = 0.0;
-	gp->count = 0;
-    }
+  for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; gp < gend; 
+       gp++) {
+    gp->lastY = 0.0;
+    gp->count = 0;
+  }
 }
 
-void
-Blt_DestroyBarSets(Graph *graphPtr)
+void Blt_DestroyBarSets(Graph *graphPtr)
 {
-    Tcl_HashSearch iter;
-    Tcl_HashEntry *hPtr;
-
-    if (graphPtr->barGroups != NULL) {
-	free(graphPtr->barGroups);
-	graphPtr->barGroups = NULL;
-    }
-    graphPtr->nBarGroups = 0;
-    for (hPtr = Tcl_FirstHashEntry(&graphPtr->setTable, &iter); 
-	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
-	Tcl_HashTable *tablePtr;
+  Tcl_HashSearch iter;
+  Tcl_HashEntry *hPtr;
+
+  if (graphPtr->barGroups != NULL) {
+    free(graphPtr->barGroups);
+    graphPtr->barGroups = NULL;
+  }
+  graphPtr->nBarGroups = 0;
+  for (hPtr = Tcl_FirstHashEntry(&graphPtr->setTable, &iter); 
+       hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+    Tcl_HashTable *tablePtr;
 	
-	tablePtr = Tcl_GetHashValue(hPtr);
-	Tcl_DeleteHashTable(tablePtr);
-	free(tablePtr);
-    }
-    Tcl_DeleteHashTable(&graphPtr->setTable);
-    Tcl_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
+    tablePtr = Tcl_GetHashValue(hPtr);
+    Tcl_DeleteHashTable(tablePtr);
+    free(tablePtr);
+  }
+  Tcl_DeleteHashTable(&graphPtr->setTable);
+  Tcl_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
 }
diff --git a/src/bltGrElemLine.C b/src/bltGrElemLine.C
index dc81500..c52a0a5 100644
--- a/src/bltGrElemLine.C
+++ b/src/bltGrElemLine.C
@@ -409,7 +409,7 @@ extern Blt_CustomOption bltYAxisOption;
 #define DEF_LINE_STATE			"normal"
 #define DEF_LINE_STIPPLE		(char *)NULL
 #define DEF_LINE_STYLES			""
-#define DEF_LINE_SYMBOL			"circle"
+#define DEF_LINE_SYMBOL			"none"
 #define DEF_LINE_TAGS			"all"
 #define DEF_LINE_X_DATA			(char *)NULL
 #define DEF_LINE_Y_DATA			(char *)NULL
@@ -428,7 +428,7 @@ extern Blt_CustomOption bltYAxisOption;
 #define DEF_PEN_OUTLINE_COLOR		"defcolor"
 #define DEF_PEN_OUTLINE_WIDTH 		"1"
 #define DEF_PEN_PIXELS			"0.1i"
-#define DEF_PEN_SYMBOL			"circle"
+#define DEF_PEN_SYMBOL			"none"
 #define DEF_PEN_TYPE			"line"
 #define	DEF_PEN_VALUE_ANCHOR		"s"
 #define	DEF_PEN_VALUE_COLOR		black
@@ -1292,7 +1292,7 @@ InitLinePen(LinePen *penPtr)
     penPtr->symbol.bitmap = penPtr->symbol.mask = None;
     penPtr->symbol.outlineColor = penPtr->symbol.fillColor = COLOR_DEFAULT;
     penPtr->symbol.outlineWidth = penPtr->traceWidth = 1;
-    penPtr->symbol.type = SYMBOL_CIRCLE;
+    penPtr->symbol.type = SYMBOL_NONE;
     penPtr->valueShow = SHOW_NONE;
 }
 
diff --git a/tests/base.tcl b/tests/base.tcl
index 863285a..21dd1d7 100644
--- a/tests/base.tcl
+++ b/tests/base.tcl
@@ -86,13 +86,11 @@ proc bltLineGraph {w} {
     $graph element create data1 \
 	-xdata { 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 } \
 	-ydata { 13 25 36 46 55 64 70 75 80 90} \
-	-color blue \
-	-symbol {}
+	-color blue
     $graph element create data2 \
 	-xdata { 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0 } \
 	-ydata { 26 50 72 92 110 128 140 150 160 180} \
-	-color red \
-	-symbol {}
+	-color red
     $graph legend configure -title "Legend"
 
     update