Better align with TEA's expected file layout

TEA is quite picky about packages placing their sources in the generic/,
unix/, etc. directories.  An immediate benefit of this change is support
for building in a separate directory.

1 files changed, 2486 insertions, 0 deletions

diff --git a/generic/tkbltGrElemLine.C b/generic/tkbltGrElemLine.C
new file mode 100644
index 0000000..8da4279
--- /dev/null
+++ b/generic/tkbltGrElemLine.C
@@ -0,0 +1,2486 @@
+/*
+ * Smithsonian Astrophysical Observatory, Cambridge, MA, USA
+ * This code has been modified under the terms listed below and is made
+ * available under the same terms.
+ */
+
+/*
+ *	Copyright (c) 1993 George A Howlett.
+ *
+ *	Permission is hereby granted, free of charge, to any person obtaining
+ *	a copy of this software and associated documentation files (the
+ *	"Software"), to deal in the Software without restriction, including
+ *	without limitation the rights to use, copy, modify, merge, publish,
+ *	distribute, sublicense, and/or sell copies of the Software, and to
+ *	permit persons to whom the Software is furnished to do so, subject to
+ *	the following conditions:
+ *
+ *	The above copyright notice and this permission notice shall be
+ *	included in all copies or substantial portions of the Software.
+ *
+ *	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *	LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *	OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *	WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <float.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cmath>
+
+#include "tkbltGraph.h"
+#include "tkbltGrElemLine.h"
+#include "tkbltGrElemOption.h"
+#include "tkbltGrAxis.h"
+#include "tkbltGrMisc.h"
+#include "tkbltGrDef.h"
+#include "tkbltConfig.h"
+#include "tkbltGrPSOutput.h"
+
+using namespace Blt;
+
+#define SEARCH_X	0
+#define SEARCH_Y	1
+#define SEARCH_BOTH	2
+
+#define SEARCH_POINTS	0	// closest data point.
+#define SEARCH_TRACES	1	// closest point on trace.
+#define SEARCH_AUTO	2	// traces if linewidth is > 0 and more than one
+
+#define MIN3(a,b,c)	(((a)<(b))?(((a)<(c))?(a):(c)):(((b)<(c))?(b):(c)))
+#define PointInRegion(e,x,y) (((x) <= (e)->right) && ((x) >= (e)->left) && ((y) <= (e)->bottom) && ((y) >= (e)->top))
+
+#define BROKEN_TRACE(dir,last,next) (((dir == INCREASING)&&(next < last)) || ((dir == DECREASING)&&(next > last)))
+#define DRAW_SYMBOL() (symbolInterval_==0||(symbolCounter_%symbolInterval_)==0)
+
+static const char* symbolMacros[] =
+  {"Li", "Sq", "Ci", "Di", "Pl", "Cr", "Sp", "Sc", "Tr", "Ar", "Bm", NULL};
+
+// OptionSpecs
+
+static const char* smoothObjOption[] = 
+  {"linear", "step", "cubic", "quadratic", "catrom", NULL};
+
+static const char* penDirObjOption[] = 
+  {"increasing", "decreasing", "both", NULL};
+
+static Tk_ObjCustomOption styleObjOption =
+  {
+    "styles", StyleSetProc, StyleGetProc, StyleRestoreProc, StyleFreeProc, 
+    (ClientData)sizeof(LineStyle)
+  };
+
+extern Tk_ObjCustomOption penObjOption;
+extern Tk_ObjCustomOption pairsObjOption;
+extern Tk_ObjCustomOption valuesObjOption;
+extern Tk_ObjCustomOption xAxisObjOption;
+extern Tk_ObjCustomOption yAxisObjOption;
+
+static Tk_OptionSpec optionSpecs[] = {
+  {TK_OPTION_CUSTOM, "-activepen", "activePen", "ActivePen",
+   "active", -1, Tk_Offset(LineElementOptions, activePenPtr), 
+   TK_OPTION_NULL_OK, &penObjOption, LAYOUT},
+  {TK_OPTION_BORDER, "-areabackground", "areaBackground", "AreaBackground",
+   NULL, -1, Tk_Offset(LineElementOptions, fillBg), 
+   TK_OPTION_NULL_OK, NULL, LAYOUT},
+  {TK_OPTION_CUSTOM, "-bindtags", "bindTags", "BindTags", 
+   "all", -1, Tk_Offset(LineElementOptions, tags), 
+   TK_OPTION_NULL_OK, &listObjOption, 0},
+  {TK_OPTION_COLOR, "-color", "color", "Color", 
+   STD_NORMAL_FOREGROUND, -1, 
+   Tk_Offset(LineElementOptions, builtinPen.traceColor), 0, NULL, CACHE},
+  {TK_OPTION_CUSTOM, "-dashes", "dashes", "Dashes", 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.traceDashes), 
+   TK_OPTION_NULL_OK, &dashesObjOption, CACHE},
+  {TK_OPTION_CUSTOM, "-data", "data", "Data", 
+   NULL, -1, Tk_Offset(LineElementOptions, coords),
+   TK_OPTION_NULL_OK, &pairsObjOption, RESET},
+  {TK_OPTION_COLOR, "-errorbarcolor", "errorBarColor", "ErrorBarColor",
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.errorBarColor), 
+   TK_OPTION_NULL_OK, NULL, CACHE},
+  {TK_OPTION_PIXELS,"-errorbarwidth", "errorBarWidth", "ErrorBarWidth",
+   "1", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarLineWidth),
+   0, NULL, CACHE},
+  {TK_OPTION_PIXELS, "-errorbarcap", "errorBarCap", "ErrorBarCap", 
+   "0", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarCapWidth),
+   0, NULL, LAYOUT},
+  {TK_OPTION_COLOR, "-fill", "fill", "Fill", 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.symbol.fillColor), 
+   TK_OPTION_NULL_OK, NULL, CACHE},
+  {TK_OPTION_BOOLEAN, "-hide", "hide", "Hide", 
+   "no", -1, Tk_Offset(LineElementOptions, hide), 0, NULL, LAYOUT},
+  {TK_OPTION_STRING, "-label", "label", "Label", 
+   NULL, -1, Tk_Offset(LineElementOptions, label), 
+   TK_OPTION_NULL_OK | TK_OPTION_DONT_SET_DEFAULT, NULL, LAYOUT},
+  {TK_OPTION_RELIEF, "-legendrelief", "legendRelief", "LegendRelief",
+   "flat", -1, Tk_Offset(LineElementOptions, legendRelief), 0, NULL, LAYOUT},
+  {TK_OPTION_PIXELS, "-linewidth", "lineWidth", "LineWidth",
+   "1", -1, Tk_Offset(LineElementOptions, builtinPen.traceWidth),
+   0, NULL, CACHE},
+  {TK_OPTION_CUSTOM, "-mapx", "mapX", "MapX",
+   "x", -1, Tk_Offset(LineElementOptions, xAxis), 0, &xAxisObjOption, RESET},
+  {TK_OPTION_CUSTOM, "-mapy", "mapY", "MapY",
+   "y", -1, Tk_Offset(LineElementOptions, yAxis), 0, &yAxisObjOption, RESET},
+  {TK_OPTION_INT, "-maxsymbols", "maxSymbols", "MaxSymbols",
+   "0", -1, Tk_Offset(LineElementOptions, reqMaxSymbols), 0, NULL, CACHE},
+  {TK_OPTION_COLOR, "-offdash", "offDash", "OffDash", 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.traceOffColor),
+   TK_OPTION_NULL_OK, NULL, CACHE},
+  {TK_OPTION_COLOR, "-outline", "outline", "Outline", 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.symbol.outlineColor), 
+   TK_OPTION_NULL_OK, NULL, CACHE},
+  {TK_OPTION_PIXELS, "-outlinewidth", "outlineWidth", "OutlineWidth",
+   "1", -1, Tk_Offset(LineElementOptions, builtinPen.symbol.outlineWidth),
+   0, NULL, CACHE},
+  {TK_OPTION_CUSTOM, "-pen", "pen", "Pen",
+   NULL, -1, Tk_Offset(LineElementOptions, normalPenPtr), 
+   TK_OPTION_NULL_OK, &penObjOption, LAYOUT},
+  {TK_OPTION_PIXELS, "-pixels", "pixels", "Pixels", 
+   "0.1i", -1, Tk_Offset(LineElementOptions, builtinPen.symbol.size), 
+   0, NULL, LAYOUT},
+  {TK_OPTION_DOUBLE, "-reduce", "reduce", "Reduce",
+   "0", -1, Tk_Offset(LineElementOptions, rTolerance), 0, NULL, RESET},
+  {TK_OPTION_BOOLEAN, "-scalesymbols", "scaleSymbols", "ScaleSymbols",
+   "yes", -1, Tk_Offset(LineElementOptions, scaleSymbols), 0, NULL, LAYOUT},
+  {TK_OPTION_STRING_TABLE, "-showerrorbars", "showErrorBars", "ShowErrorBars",
+   "both", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarShow), 
+   0, &fillObjOption, LAYOUT},
+  {TK_OPTION_STRING_TABLE, "-showvalues", "showValues", "ShowValues",
+   "none", -1, Tk_Offset(LineElementOptions, builtinPen.valueShow), 
+   0, &fillObjOption, CACHE},
+  {TK_OPTION_STRING_TABLE, "-smooth", "smooth", "Smooth", 
+   "linear", -1, Tk_Offset(LineElementOptions, reqSmooth), 
+   0, &smoothObjOption, LAYOUT},
+  {TK_OPTION_CUSTOM, "-styles", "styles", "Styles",
+   "", -1, Tk_Offset(LineElementOptions, stylePalette), 
+   0, &styleObjOption, RESET},
+  {TK_OPTION_STRING_TABLE, "-symbol", "symbol", "Symbol",
+   "none", -1, Tk_Offset(LineElementOptions, builtinPen.symbol), 
+   0, &symbolObjOption, CACHE},
+  {TK_OPTION_STRING_TABLE, "-trace", "trace", "Trace",
+   "both", -1, Tk_Offset(LineElementOptions, penDir), 
+   0, &penDirObjOption, RESET},
+  {TK_OPTION_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor",
+   "s", -1, Tk_Offset(LineElementOptions, builtinPen.valueStyle.anchor),
+   0, NULL, CACHE},
+  {TK_OPTION_COLOR, "-valuecolor", "valueColor", "ValueColor",
+   STD_NORMAL_FOREGROUND,-1,
+   Tk_Offset(LineElementOptions, builtinPen.valueStyle.color),
+   0, NULL, CACHE},
+  {TK_OPTION_FONT, "-valuefont", "valueFont", "ValueFont",
+   STD_FONT_SMALL, -1, 
+   Tk_Offset(LineElementOptions, builtinPen.valueStyle.font),
+   0, NULL, CACHE},
+  {TK_OPTION_STRING, "-valueformat", "valueFormat", "ValueFormat",
+   "%g", -1, Tk_Offset(LineElementOptions, builtinPen.valueFormat), 
+   TK_OPTION_NULL_OK, NULL, CACHE},
+  {TK_OPTION_DOUBLE, "-valuerotate", "valueRotate", "ValueRotate",
+   "0", -1, Tk_Offset(LineElementOptions, builtinPen.valueStyle.angle),
+   0, NULL, CACHE},
+  {TK_OPTION_CUSTOM, "-weights", "weights", "Weights",
+   NULL, -1, Tk_Offset(LineElementOptions, w), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_SYNONYM, "-x", NULL, NULL, 
+   NULL, 0, -1, 0, (ClientData)"-xdata", 0},
+  {TK_OPTION_CUSTOM, "-xdata", "xData", "XData", 
+   NULL, -1, Tk_Offset(LineElementOptions, coords.x), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_CUSTOM, "-xerror", "xError", "XError", 
+   NULL, -1, Tk_Offset(LineElementOptions, xError), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_CUSTOM, "-xhigh", "xHigh", "XHigh", 
+   NULL, -1, Tk_Offset(LineElementOptions, xHigh), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_CUSTOM, "-xlow", "xLow", "XLow", 
+   NULL, -1, Tk_Offset(LineElementOptions, xLow), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_SYNONYM, "-y", NULL, NULL, 
+   NULL, 0, -1, 0, (ClientData)"-ydata", 0},
+  {TK_OPTION_CUSTOM, "-ydata", "yData", "YData", 
+   NULL, -1, Tk_Offset(LineElementOptions, coords.y), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_CUSTOM, "-yerror", "yError", "YError", 
+   NULL, -1, Tk_Offset(LineElementOptions, yError), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_CUSTOM, "-yhigh", "yHigh", "YHigh",
+   NULL, -1, Tk_Offset(LineElementOptions, yHigh), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_CUSTOM, "-ylow", "yLow", "YLow", 
+   NULL, -1, Tk_Offset(LineElementOptions, yLow), 
+   TK_OPTION_NULL_OK, &valuesObjOption, RESET},
+  {TK_OPTION_END, NULL, NULL, NULL, NULL, 0, -1, 0, 0, 0}
+};
+
+LineElement::LineElement(Graph* graphPtr, const char* name, Tcl_HashEntry* hPtr)
+  : Element(graphPtr, name, hPtr)
+{
+  smooth_ = LINEAR;
+  fillPts_ =NULL;
+  nFillPts_ = 0;
+
+  symbolPts_.points =NULL;
+  symbolPts_.length =0;
+  symbolPts_.map =NULL;
+  activePts_.points =NULL;
+  activePts_.length =0;
+  activePts_.map =NULL;
+
+  xeb_.segments =NULL;
+  xeb_.map =NULL;
+  xeb_.length =0;
+  yeb_.segments =NULL;
+  yeb_.map =NULL;
+  yeb_.length =0;
+
+  symbolInterval_ =0;
+  symbolCounter_ =0;
+  traces_ =NULL;
+
+  ops_ = (LineElementOptions*)calloc(1, sizeof(LineElementOptions));
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  ops->elemPtr = (Element*)this;
+
+  builtinPenPtr = new LinePen(graphPtr, "builtin", &ops->builtinPen);
+  ops->builtinPenPtr = builtinPenPtr;
+
+  optionTable_ = Tk_CreateOptionTable(graphPtr->interp_, optionSpecs);
+
+  ops->stylePalette = new Chain();
+  // this is an option and will be freed via Tk_FreeConfigOptions
+  // By default an element's name and label are the same
+  ops->label = Tcl_Alloc(strlen(name)+1);
+  if (name)
+    strcpy((char*)ops->label,(char*)name);
+
+  Tk_InitOptions(graphPtr->interp_, (char*)&(ops->builtinPen),
+		 builtinPenPtr->optionTable(), graphPtr->tkwin_);
+}
+
+LineElement::~LineElement()
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  if (builtinPenPtr)
+    delete builtinPenPtr;
+
+  reset();
+
+  if (ops->stylePalette) {
+    freeStylePalette(ops->stylePalette);
+    delete ops->stylePalette;
+  }
+
+  if (fillPts_)
+    delete [] fillPts_;
+}
+
+int LineElement::configure()
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  if (builtinPenPtr->configure() != TCL_OK)
+    return TCL_ERROR;
+
+  // Point to the static normal/active pens if no external pens have been
+  // selected.
+  ChainLink* link = Chain_FirstLink(ops->stylePalette);
+  if (!link) {
+    link = new ChainLink(sizeof(LineStyle));
+    ops->stylePalette->linkAfter(link, NULL);
+  } 
+  LineStyle* stylePtr = (LineStyle*)Chain_GetValue(link);
+  stylePtr->penPtr = NORMALPEN(ops);
+
+  return TCL_OK;
+}
+
+void LineElement::map()
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+    
+  if (!link)
+    return;
+
+  reset();
+  if (!ops->coords.x || !ops->coords.y ||
+      !ops->coords.x->nValues() || !ops->coords.y->nValues())
+    return;
+  int np = NUMBEROFPOINTS(ops);
+
+  MapInfo mi;
+  getScreenPoints(&mi);
+  mapSymbols(&mi);
+
+  if (nActiveIndices_ > 0)
+    mapActiveSymbols();
+
+  // Map connecting line segments if they are to be displayed.
+  smooth_ = (Smoothing)ops->reqSmooth;
+  if ((np > 1) && (ops->builtinPen.traceWidth > 0)) {
+    // Do smoothing if necessary.  This can extend the coordinate array,
+    // so both mi.points and mi.nPoints may change.
+    switch (smooth_) {
+    case STEP:
+      generateSteps(&mi);
+      break;
+
+    case CUBIC:
+    case QUADRATIC:
+      // Can't interpolate with less than three points
+      if (mi.nScreenPts < 3)
+	smooth_ = LINEAR;
+      else
+	generateSpline(&mi);
+      break;
+
+    case CATROM:
+      // Can't interpolate with less than three points
+      if (mi.nScreenPts < 3)
+	smooth_ = LINEAR;
+      else
+	generateParametricSpline(&mi);
+      break;
+
+    default:
+      break;
+    }
+    if (ops->rTolerance > 0.0)
+      reducePoints(&mi, ops->rTolerance);
+
+    if (ops->fillBg)
+      mapFillArea(&mi);
+
+    mapTraces(&mi);
+  }
+  delete [] mi.screenPts;
+  delete [] mi.map;
+
+  // Set the symbol size of all the pen styles
+  for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+       link = Chain_NextLink(link)) {
+    LineStyle* stylePtr = (LineStyle*)Chain_GetValue(link);
+    LinePen* penPtr = (LinePen *)stylePtr->penPtr;
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+    int size = scaleSymbol(penOps->symbol.size);
+    stylePtr->symbolSize = size;
+    stylePtr->errorBarCapWidth = penOps->errorBarCapWidth;
+  }
+
+  LineStyle** styleMap = (LineStyle**)StyleMap();
+  if (((ops->yHigh && ops->yHigh->nValues() > 0) &&
+       (ops->yLow && ops->yLow->nValues() > 0)) ||
+      ((ops->xHigh && ops->xHigh->nValues() > 0) &&
+       (ops->xLow && ops->xLow->nValues() > 0)) ||
+      (ops->xError && ops->xError->nValues() > 0) ||
+      (ops->yError && ops->yError->nValues() > 0)) {
+    mapErrorBars(styleMap);
+  }
+
+  mergePens(styleMap);
+  delete [] styleMap;
+}
+
+void LineElement::extents(Region2d *extsPtr)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  extsPtr->top = extsPtr->left = DBL_MAX;
+  extsPtr->bottom = extsPtr->right = -DBL_MAX;
+
+  if (!ops->coords.x || !ops->coords.y ||
+      !ops->coords.x->nValues() || !ops->coords.y->nValues())
+    return;
+  int np = NUMBEROFPOINTS(ops);
+
+  extsPtr->right = ops->coords.x->max();
+  AxisOptions* axisxops = (AxisOptions*)ops->xAxis->ops();
+  if ((ops->coords.x->min() <= 0.0) && (axisxops->logScale))
+    extsPtr->left = FindElemValuesMinimum(ops->coords.x, DBL_MIN);
+  else
+    extsPtr->left = ops->coords.x->min();
+
+  extsPtr->bottom = ops->coords.y->max();
+  AxisOptions* axisyops = (AxisOptions*)ops->yAxis->ops();
+  if ((ops->coords.y->min() <= 0.0) && (axisyops->logScale))
+    extsPtr->top = FindElemValuesMinimum(ops->coords.y, DBL_MIN);
+  else
+    extsPtr->top = ops->coords.y->min();
+
+  // Correct the data limits for error bars
+  if (ops->xError && ops->xError->nValues() > 0) {
+    np = MIN(ops->xError->nValues(), np);
+    for (int ii=0; ii<np; ii++) {
+      double x = ops->coords.x->values_[ii] + ops->xError->values_[ii];
+      if (x > extsPtr->right)
+	extsPtr->right = x;
+
+      x = ops->coords.x->values_[ii] - ops->xError->values_[ii];
+      AxisOptions* axisxops = (AxisOptions*)ops->xAxis->ops();
+      if (axisxops->logScale) {
+	// Mirror negative values, instead of ignoring them
+	if (x < 0.0)
+	  x = -x;
+	if ((x > DBL_MIN) && (x < extsPtr->left))
+	  extsPtr->left = x;
+      } 
+      else if (x < extsPtr->left)
+	extsPtr->left = x;
+    }		     
+  }
+  else {
+    if (ops->xHigh && 
+	(ops->xHigh->nValues() > 0) && 
+	(ops->xHigh->max() > extsPtr->right)) {
+      extsPtr->right = ops->xHigh->max();
+    }
+    if (ops->xLow && ops->xLow->nValues() > 0) {
+      double left;
+      if ((ops->xLow->min() <= 0.0) && (axisxops->logScale))
+	left = FindElemValuesMinimum(ops->xLow, DBL_MIN);
+      else
+	left = ops->xLow->min();
+
+      if (left < extsPtr->left)
+	extsPtr->left = left;
+    }
+  }
+    
+  if (ops->yError && ops->yError->nValues() > 0) {
+    np = MIN(ops->yError->nValues(), np);
+    for (int ii=0; ii<np; ii++) {
+      double y = ops->coords.y->values_[ii] + ops->yError->values_[ii];
+      if (y > extsPtr->bottom)
+	extsPtr->bottom = y;
+
+      y = ops->coords.y->values_[ii] - ops->yError->values_[ii];
+      AxisOptions* axisyops = (AxisOptions*)ops->yAxis->ops();
+      if (axisyops->logScale) {
+	// Mirror negative values, instead of ignoring them
+	if (y < 0.0)
+	  y = -y;
+	if ((y > DBL_MIN) && (y < extsPtr->left))
+	  extsPtr->top = y;
+      }
+      else if (y < extsPtr->top)
+	extsPtr->top = y;
+    }
+  }
+  else {
+    if (ops->yHigh && (ops->yHigh->nValues() > 0) && 
+	(ops->yHigh->max() > extsPtr->bottom))
+      extsPtr->bottom = ops->yHigh->max();
+
+    if (ops->yLow && ops->yLow->nValues() > 0) {
+      double top;
+      if ((ops->yLow->min() <= 0.0) && (axisyops->logScale))
+	top = FindElemValuesMinimum(ops->yLow, DBL_MIN);
+      else
+	top = ops->yLow->min();
+
+      if (top < extsPtr->top)
+	extsPtr->top = top;
+    }
+  }
+}
+
+void LineElement::closest()
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
+
+  ClosestSearch* searchPtr = &gops->search;
+  int mode = searchPtr->mode;
+  if (mode == SEARCH_AUTO) {
+    LinePen* penPtr = NORMALPEN(ops);
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+    mode = SEARCH_POINTS;
+    if ((NUMBEROFPOINTS(ops) > 1) && (penOps->traceWidth > 0))
+      mode = SEARCH_TRACES;
+  }
+  if (mode == SEARCH_POINTS)
+    closestPoint(searchPtr);
+  else {
+    int found = closestTrace();
+    if ((!found) && (searchPtr->along != SEARCH_BOTH))
+      closestPoint(searchPtr);
+  }
+}
+
+void LineElement::draw(Drawable drawable)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  LinePen* penPtr = NORMALPEN(ops);
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  if (ops->hide)
+    return;
+
+  // Fill area under the curve
+  if (ops->fillBg && fillPts_) {
+    XPoint*points = new XPoint[nFillPts_];
+
+    unsigned int count =0;
+    for (Point2d *pp = fillPts_, *endp = pp + nFillPts_; pp < endp; pp++) {
+      points[count].x = pp->x;
+      points[count].y = pp->y;
+      count++;
+    }
+    Tk_Fill3DPolygon(graphPtr_->tkwin_, drawable, ops->fillBg, points, 
+		     nFillPts_, 0, TK_RELIEF_FLAT);
+    delete [] points;
+  }
+
+  // traces
+  if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
+    drawTraces(drawable, penPtr);
+
+  // Symbols, error bars, values
+  if (ops->reqMaxSymbols > 0) {
+    int total = 0;
+    for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+	 link = Chain_NextLink(link)) {
+      LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+      total += stylePtr->symbolPts.length;
+    }
+    symbolInterval_ = total / ops->reqMaxSymbols;
+    symbolCounter_ = 0;
+  }
+
+  unsigned int count =0;
+  for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+       link = Chain_NextLink(link)) {
+    LineStyle* stylePtr = (LineStyle*)Chain_GetValue(link);
+    LinePen* penPtr = (LinePen *)stylePtr->penPtr;
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+    if ((stylePtr->xeb.length > 0) && (penOps->errorBarShow & SHOW_X))
+      graphPtr_->drawSegments(drawable, penPtr->errorBarGC_, 
+			      stylePtr->xeb.segments, stylePtr->xeb.length);
+
+    if ((stylePtr->yeb.length > 0) && (penOps->errorBarShow & SHOW_Y))
+      graphPtr_->drawSegments(drawable, penPtr->errorBarGC_, 
+			      stylePtr->yeb.segments, stylePtr->yeb.length);
+
+    if ((stylePtr->symbolPts.length > 0) && 
+	(penOps->symbol.type != SYMBOL_NONE))
+      drawSymbols(drawable, penPtr, stylePtr->symbolSize,
+		  stylePtr->symbolPts.length, stylePtr->symbolPts.points);
+
+    if (penOps->valueShow != SHOW_NONE)
+      drawValues(drawable, penPtr, stylePtr->symbolPts.length, 
+		 stylePtr->symbolPts.points, symbolPts_.map + count);
+
+    count += stylePtr->symbolPts.length;
+  }
+
+  symbolInterval_ = 0;
+  symbolCounter_ = 0;
+}
+
+void LineElement::drawActive(Drawable drawable)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  LinePen* penPtr = (LinePen*)ops->activePenPtr;
+  if (!penPtr)
+    return;
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  if (ops->hide || !active_)
+    return;
+
+  int symbolSize = scaleSymbol(penOps->symbol.size);
+
+  if (nActiveIndices_ > 0) {
+    mapActiveSymbols();
+
+    if (penOps->symbol.type != SYMBOL_NONE)
+      drawSymbols(drawable, penPtr, symbolSize, activePts_.length,
+		  activePts_.points);
+    if (penOps->valueShow != SHOW_NONE)
+      drawValues(drawable, penPtr, activePts_.length, activePts_.points, 
+		 activePts_.map);
+  }
+  else if (nActiveIndices_ < 0) { 
+    if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
+      drawTraces(drawable, penPtr);
+
+    if (penOps->symbol.type != SYMBOL_NONE)
+      drawSymbols(drawable, penPtr, symbolSize, symbolPts_.length,
+		  symbolPts_.points);
+
+    if (penOps->valueShow != SHOW_NONE) {
+      drawValues(drawable, penPtr, symbolPts_.length, symbolPts_.points, 
+		 symbolPts_.map);
+    }
+  }
+}
+
+void LineElement::drawSymbol(Drawable drawable, int x, int y, int size)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  LinePen* penPtr = NORMALPEN(ops);
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  if (penOps->traceWidth > 0) {
+    // Draw an extra line offset by one pixel from the previous to give a
+    // thicker appearance.  This is only for the legend entry.  This routine
+    // is never called for drawing the actual line segments.
+    XDrawLine(graphPtr_->display_, drawable, penPtr->traceGC_, x - size, y, 
+	      x + size, y);
+    XDrawLine(graphPtr_->display_, drawable, penPtr->traceGC_, x - size, y + 1,
+	      x + size, y + 1);
+  }
+  if (penOps->symbol.type != SYMBOL_NONE) {
+    Point2d point;
+    point.x = x;
+    point.y = y;
+    drawSymbols(drawable, penPtr, size, 1, &point);
+  }
+}
+
+void LineElement::print(PSOutput* psPtr)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  LinePen* penPtr = NORMALPEN(ops);
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  if (ops->hide)
+    return;
+
+  psPtr->format("\n%% Element \"%s\"\n\n", name_);
+
+  // Draw fill area
+  if (ops->fillBg && fillPts_) {
+    psPtr->append("% start fill area\n");
+    psPtr->setBackground(ops->fillBg);
+    psPtr->printPolyline(fillPts_, nFillPts_);
+    psPtr->append("gsave fill grestore\n");
+    psPtr->append("% end fill area\n");
+  }
+
+  // traces
+  if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
+    printTraces(psPtr, penPtr);
+
+  // Symbols, error bars, values
+  if (ops->reqMaxSymbols > 0) {
+    int total = 0;
+    for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+	 link = Chain_NextLink(link)) {
+      LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+      total += stylePtr->symbolPts.length;
+    }
+    symbolInterval_ = total / ops->reqMaxSymbols;
+    symbolCounter_ = 0;
+  }
+
+  unsigned int count =0;
+  for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+       link = Chain_NextLink(link)) {
+    LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+    LinePen* penPtr = (LinePen *)stylePtr->penPtr;
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+    XColor* colorPtr = penOps->errorBarColor;
+    if (!colorPtr)
+      colorPtr = penOps->traceColor;
+
+    if ((stylePtr->xeb.length > 0) && (penOps->errorBarShow & SHOW_X)) {
+      psPtr->setLineAttributes(colorPtr, penOps->errorBarLineWidth, 
+			       NULL, CapButt, JoinMiter);
+      psPtr->printSegments(stylePtr->xeb.segments, stylePtr->xeb.length);
+    }
+
+    if ((stylePtr->yeb.length > 0) && (penOps->errorBarShow & SHOW_Y)) {
+      psPtr->setLineAttributes(colorPtr, penOps->errorBarLineWidth, 
+			       NULL, CapButt, JoinMiter);
+      psPtr->printSegments(stylePtr->yeb.segments, stylePtr->yeb.length);
+    }
+
+    if ((stylePtr->symbolPts.length > 0) && 
+	(penOps->symbol.type != SYMBOL_NONE))
+      printSymbols(psPtr, penPtr, stylePtr->symbolSize, 
+		   stylePtr->symbolPts.length, stylePtr->symbolPts.points);
+
+    if (penOps->valueShow != SHOW_NONE)
+      printValues(psPtr, penPtr, stylePtr->symbolPts.length, 
+		  stylePtr->symbolPts.points, symbolPts_.map + count);
+
+    count += stylePtr->symbolPts.length;
+  }
+
+  symbolInterval_ = 0;
+  symbolCounter_ = 0;
+}
+
+void LineElement::printActive(PSOutput* psPtr)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  LinePen* penPtr = (LinePen *)ops->activePenPtr;
+  if (!penPtr)
+    return;
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  if (ops->hide || !active_)
+    return;
+
+  psPtr->format("\n%% Active Element \"%s\"\n\n", name_);
+
+  int symbolSize = scaleSymbol(penOps->symbol.size);
+  if (nActiveIndices_ > 0) {
+    mapActiveSymbols();
+
+    if (penOps->symbol.type != SYMBOL_NONE)
+      printSymbols(psPtr, penPtr, symbolSize, activePts_.length,
+			  activePts_.points);
+
+    if (penOps->valueShow != SHOW_NONE)
+      printValues(psPtr, penPtr, activePts_.length, activePts_.points,
+		  activePts_.map);
+  }
+  else if (nActiveIndices_ < 0) {
+    if ((Chain_GetLength(traces_) > 0) && (penOps->traceWidth > 0))
+      printTraces(psPtr, (LinePen*)penPtr);
+
+    if (penOps->symbol.type != SYMBOL_NONE)
+      printSymbols(psPtr, penPtr, symbolSize, symbolPts_.length, 
+		   symbolPts_.points);
+    if (penOps->valueShow != SHOW_NONE) {
+      printValues(psPtr, penPtr, symbolPts_.length, symbolPts_.points,
+		  symbolPts_.map);
+    }
+  }
+}
+
+void LineElement::printSymbol(PSOutput* psPtr, double x, double y, int size)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  LinePen* penPtr = NORMALPEN(ops);
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  if (penOps->traceWidth > 0) {
+    // Draw an extra line offset by one pixel from the previous to give a
+    // thicker appearance.  This is only for the legend entry.  This routine
+    // is never called for drawing the actual line segments.
+    psPtr->setLineAttributes(penOps->traceColor, penOps->traceWidth, 
+			      &penOps->traceDashes, CapButt, JoinMiter);
+    psPtr->format("%g %g %d Li\n", x, y, size + size);
+  }
+
+  if (penOps->symbol.type != SYMBOL_NONE) {
+    Point2d point;
+    point.x = x;
+    point.y = y;
+    printSymbols(psPtr, penPtr, size, 1, &point);
+  }
+}
+
+// Support
+
+double LineElement::distanceToLine(int x, int y, Point2d *p, Point2d *q,
+				   Point2d *t)
+{
+  double right, left, top, bottom;
+
+  *t = getProjection(x, y, p, q);
+  if (p->x > q->x)
+    right = p->x, left = q->x;
+  else
+    left = p->x, right = q->x;
+
+  if (p->y > q->y)
+    bottom = p->y, top = q->y;
+  else
+    top = p->y, bottom = q->y;
+
+  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;
+
+  return hypot((t->x - x), (t->y - y));
+}
+
+double LineElement::distanceToX(int x, int y, Point2d *p, Point2d *q, 
+				Point2d *t)
+{
+  double dx, dy;
+  double d;
+
+  if (p->x > q->x) {
+    if ((x > p->x) || (x < q->x)) {
+      return DBL_MAX;		/* X-coordinate outside line segment. */
+    }
+  } else {
+    if ((x > q->x) || (x < p->x)) {
+      return DBL_MAX;		/* X-coordinate outside line segment. */
+    }
+  }
+  dx = p->x - q->x;
+  dy = p->y - q->y;
+  t->x = (double)x;
+  if (fabs(dx) < DBL_EPSILON) {
+    double d1, d2;
+    /* 
+     * Same X-coordinate indicates a vertical line.  Pick the closest end
+     * point.
+     */
+    d1 = p->y - y;
+    d2 = q->y - y;
+    if (fabs(d1) < fabs(d2)) {
+      t->y = p->y, d = d1;
+    } else {
+      t->y = q->y, d = d2;
+    }
+  }
+  else if (fabs(dy) < DBL_EPSILON) {
+    /* Horizontal line. */
+    t->y = p->y, d = p->y - y;
+  }
+  else {
+    double m = dy / dx;
+    double b = p->y - (m * p->x);
+    t->y = (x * m) + b;
+    d = y - t->y;
+  }
+
+  return fabs(d);
+}
+
+double LineElement::distanceToY(int x, int y, Point2d *p, Point2d *q,
+				Point2d *t)
+{
+  double dx, dy;
+  double d;
+
+  if (p->y > q->y) {
+    if ((y > p->y) || (y < q->y)) {
+      return DBL_MAX;
+    }
+  }
+  else {
+    if ((y > q->y) || (y < p->y)) {
+      return DBL_MAX;
+    }
+  }
+  dx = p->x - q->x;
+  dy = p->y - q->y;
+  t->y = y;
+  if (fabs(dy) < DBL_EPSILON) {
+    double d1, d2;
+
+    /* Save Y-coordinate indicates an horizontal line. Pick the closest end
+     * point. */
+    d1 = p->x - x;
+    d2 = q->x - x;
+    if (fabs(d1) < fabs(d2)) {
+      t->x = p->x, d = d1;
+    }
+    else {
+      t->x = q->x, d = d2;
+    }
+  }
+  else if (fabs(dx) < DBL_EPSILON) {
+    /* Vertical line. */
+    t->x = p->x, d = p->x - x;
+  } 
+  else {
+    double m = dy / dx;
+    double b = p->y - (m * p->x);
+    t->x = (y - b) / m;
+    d = x - t->x;
+  }
+
+  return fabs(d);
+}
+
+int LineElement::scaleSymbol(int normalSize)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  double scale = 1.0;
+  if (ops->scaleSymbols) {
+    double xRange = (ops->xAxis->max_ - ops->xAxis->min_);
+    double yRange = (ops->yAxis->max_ - ops->yAxis->min_);
+    // Save the ranges as a baseline for future scaling
+    if (!xRange_ || !yRange_) {
+      xRange_ = xRange;
+      yRange_ = yRange;
+    }
+    else {
+      // Scale the symbol by the smallest change in the X or Y axes
+      double xScale = xRange_ / xRange;
+      double yScale = yRange_ / yRange;
+      scale = MIN(xScale, yScale);
+    }
+  }
+  int newSize = normalSize * scale;
+
+  // Don't let the size of symbols go unbounded. Both X and Win32 drawing
+  // routines assume coordinates to be a signed short int.
+  int maxSize = (int)MIN(graphPtr_->hRange_, graphPtr_->vRange_);
+  if (newSize > maxSize)
+    newSize = maxSize;
+
+  // Make the symbol size odd so that its center is a single pixel.
+  newSize |= 0x01;
+
+  return newSize;
+}
+
+void LineElement::getScreenPoints(MapInfo* mapPtr)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
+
+  if (!ops->coords.x || !ops->coords.y) {
+    mapPtr->screenPts = NULL;
+    mapPtr->nScreenPts = 0;
+    mapPtr->map = NULL;
+  }
+
+  int np = NUMBEROFPOINTS(ops);
+  double* x = ops->coords.x->values_;
+  double* y = ops->coords.y->values_;
+  Point2d* points = new Point2d[np];
+  int* map = new int[np];
+
+  int count = 0;
+  if (gops->inverted) {
+    for (int ii=0; ii<np; ii++) {
+      if ((isfinite(x[ii])) && (isfinite(y[ii]))) {
+	points[count].x = ops->yAxis->hMap(y[ii]);
+	points[count].y = ops->xAxis->vMap(x[ii]);
+	map[count] = ii;
+	count++;
+      }
+    }
+  }
+  else {
+    for (int ii=0; ii< np; ii++) {
+      if ((isfinite(x[ii])) && (isfinite(y[ii]))) {
+	points[count].x = ops->xAxis->hMap(x[ii]);
+	points[count].y = ops->yAxis->vMap(y[ii]);
+	map[count] = ii;
+	count++;
+      }
+    }
+  }
+  mapPtr->screenPts = points;
+  mapPtr->nScreenPts = count;
+  mapPtr->map = map;
+}
+
+void LineElement::reducePoints(MapInfo *mapPtr, double tolerance)
+{
+  int* simple = new int[mapPtr->nScreenPts];
+  int* map = new int[mapPtr->nScreenPts];
+  Point2d* screenPts = new Point2d[mapPtr->nScreenPts];
+  int np = simplify(mapPtr->screenPts, 0, mapPtr->nScreenPts - 1, 
+		    tolerance, simple);
+  for (int ii=0; ii<np; ii++) {
+    int kk = simple[ii];
+    screenPts[ii] = mapPtr->screenPts[kk];
+    map[ii] = mapPtr->map[kk];
+  }
+  delete [] simple;
+
+  delete [] mapPtr->screenPts;
+  mapPtr->screenPts = screenPts;
+  delete [] mapPtr->map;
+  mapPtr->map = map;
+  mapPtr->nScreenPts = np;
+}
+
+// Douglas-Peucker line simplification algorithm
+int LineElement::simplify(Point2d *inputPts, int low, int high, 
+			  double tolerance, int *indices)
+{
+#define StackPush(a)	s++, stack[s] = (a)
+#define StackPop(a)	(a) = stack[s], s--
+#define StackEmpty()	(s < 0)
+#define StackTop()	stack[s]
+    int split = -1; 
+    double dist2, tolerance2;
+    int s = -1;			/* Points to top stack item. */
+
+    int* stack = new int[high - low + 1];
+    StackPush(high);
+    int count = 0;
+    indices[count++] = 0;
+    tolerance2 = tolerance * tolerance;
+    while (!StackEmpty()) {
+	dist2 = findSplit(inputPts, low, StackTop(), &split);
+	if (dist2 > tolerance2)
+	    StackPush(split);
+	else {
+	    indices[count++] = StackTop();
+	    StackPop(low);
+	}
+    } 
+    delete [] stack;
+    return count;
+}
+
+double LineElement::findSplit(Point2d *points, int i, int j, int *split)	
+{    
+    double maxDist2 = -1.0;
+    if ((i + 1) < j) {
+	double a = points[i].y - points[j].y;
+	double b = points[j].x - points[i].x;
+	double c = (points[i].x * points[j].y) - (points[i].y * points[j].x);
+	for (int kk = (i + 1); kk < j; kk++) {
+	    double dist2 = (points[kk].x * a) + (points[kk].y * b) + c;
+	    if (dist2 < 0.0)
+		dist2 = -dist2;	
+
+	    // Track the maximum.
+	    if (dist2 > maxDist2) {
+		maxDist2 = dist2;
+		*split = kk;
+	    }
+	}
+	// Correction for segment length---should be redone if can == 0
+	maxDist2 *= maxDist2 / (a * a + b * b);
+    } 
+    return maxDist2;
+}
+
+void LineElement::generateSteps(MapInfo *mapPtr)
+{
+  int newSize = ((mapPtr->nScreenPts - 1) * 2) + 1;
+  Point2d* screenPts = new Point2d[newSize];
+  int* map = new int[newSize];
+  screenPts[0] = mapPtr->screenPts[0];
+  map[0] = 0;
+
+  int count = 1;
+  for (int i = 1; i < mapPtr->nScreenPts; i++) {
+    screenPts[count + 1] = mapPtr->screenPts[i];
+
+    // Hold last y-coordinate, use new x-coordinate
+    screenPts[count].x = screenPts[count + 1].x;
+    screenPts[count].y = screenPts[count - 1].y;
+
+    // Use the same style for both the hold and the step points
+    map[count] = map[count + 1] = mapPtr->map[i];
+    count += 2;
+  }
+  delete [] mapPtr->map;
+  mapPtr->map = map;
+  delete [] mapPtr->screenPts;
+  mapPtr->screenPts = screenPts;
+  mapPtr->nScreenPts = newSize;
+}
+
+void LineElement::generateSpline(MapInfo *mapPtr)
+{
+  int nOrigPts = mapPtr->nScreenPts;
+  Point2d* origPts = mapPtr->screenPts;
+
+  // check points are not monotonically increasing
+  for (int ii=0, jj=1; jj<nOrigPts; ii++, jj++) {
+    if (origPts[jj].x <= origPts[ii].x)
+      return;
+  }
+  if (((origPts[0].x > (double)graphPtr_->right_)) ||
+      ((origPts[mapPtr->nScreenPts - 1].x < (double)graphPtr_->left_)))
+    return;
+
+  // The spline is computed in screen coordinates instead of data points so
+  // that we can select the abscissas of the interpolated points from each
+  // pixel horizontally across the plotting area.
+  int extra = (graphPtr_->right_ - graphPtr_->left_) + 1;
+  if (extra < 1)
+    return;
+
+  int niPts = nOrigPts + extra + 1;
+  Point2d* iPts = new Point2d[niPts];
+  int* map = new int[niPts];
+
+  // Populate the x2 array with both the original X-coordinates and extra
+  // X-coordinates for each horizontal pixel that the line segment contains
+  int count = 0;
+  for (int ii=0, jj=1; jj<nOrigPts; ii++, jj++) {
+    // Add the original x-coordinate
+    iPts[count].x = origPts[ii].x;
+
+    // Include the starting offset of the point in the offset array
+    map[count] = mapPtr->map[ii];
+    count++;
+
+    // Is any part of the interval (line segment) in the plotting area? 
+    if ((origPts[jj].x >= (double)graphPtr_->left_) || 
+	(origPts[ii].x <= (double)graphPtr_->right_)) {
+      double x = origPts[ii].x + 1.0;
+
+      /*
+       * Since the line segment may be partially clipped on the left or
+       * right side, the points to interpolate are always interior to
+       * the plotting area.
+       *
+       *           left			    right
+       *      x1----|---------------------------|---x2
+       *
+       * Pick the max of the starting X-coordinate and the left edge and
+       * the min of the last X-coordinate and the right edge.
+       */
+      x = MAX(x, (double)graphPtr_->left_);
+      double last = MIN(origPts[jj].x, (double)graphPtr_->right_);
+
+      // Add the extra x-coordinates to the interval
+      while (x < last) {
+	map[count] = mapPtr->map[ii];
+	iPts[count++].x = x;
+	x++;
+      }
+    }
+  }
+  niPts = count;
+  int result = 0;
+  if (smooth_ == CUBIC)
+    result = naturalSpline(origPts, nOrigPts, iPts, niPts);
+  else if (smooth_ == QUADRATIC)
+    result = quadraticSpline(origPts, nOrigPts, iPts, niPts);
+
+  // The spline interpolation failed.  We will fall back to the current
+  // coordinates and do no smoothing (standard line segments)
+  if (!result) {
+    smooth_ = LINEAR;
+    delete [] iPts;
+    delete [] map;
+  }
+  else {
+    delete [] mapPtr->map;
+    mapPtr->map = map;
+    delete [] mapPtr->screenPts;
+    mapPtr->screenPts = iPts;
+    mapPtr->nScreenPts = niPts;
+  }
+}
+
+void LineElement::generateParametricSpline(MapInfo *mapPtr)
+{
+  int nOrigPts = mapPtr->nScreenPts;
+  Point2d *origPts = mapPtr->screenPts;
+
+  Region2d exts;
+  graphPtr_->extents(&exts);
+
+  /* 
+   * Populate the x2 array with both the original X-coordinates and extra
+   * X-coordinates for each horizontal pixel that the line segment contains.
+   */
+  int count = 1;
+  for (int i = 0, j = 1; j < nOrigPts; i++, j++) {
+    Point2d p = origPts[i];
+    Point2d q = origPts[j];
+    count++;
+    if (lineRectClip(&exts, &p, &q))
+      count += (int)(hypot(q.x - p.x, q.y - p.y) * 0.5);
+  }
+  int niPts = count;
+  Point2d *iPts = new Point2d[niPts];
+  int* map = new int[niPts];
+
+  /* 
+   * FIXME: This is just plain wrong.  The spline should be computed
+   *        and evaluated in separate steps.  This will mean breaking
+   *	      up this routine since the catrom coefficients can be
+   *	      independently computed for original data point.  This 
+   *	      also handles the problem of allocating enough points 
+   *	      since evaluation is independent of the number of points 
+   *		to be evalualted.  The interpolated 
+   *	      line segments should be clipped, not the original segments.
+   */
+  count = 0;
+  int i,j;
+  for (i = 0, j = 1; j < nOrigPts; i++, j++) {
+    Point2d p = origPts[i];
+    Point2d q = origPts[j];
+
+    double d = hypot(q.x - p.x, q.y - p.y);
+    /* Add the original x-coordinate */
+    iPts[count].x = (double)i;
+    iPts[count].y = 0.0;
+
+    /* Include the starting offset of the point in the offset array */
+    map[count] = mapPtr->map[i];
+    count++;
+
+    /* Is any part of the interval (line segment) in the plotting
+     * area?  */
+
+    if (lineRectClip(&exts, &p, &q)) {
+      double dp, dq;
+
+      /* Distance of original point to p. */
+      dp = hypot(p.x - origPts[i].x, p.y - origPts[i].y);
+      /* Distance of original point to q. */
+      dq = hypot(q.x - origPts[i].x, q.y - origPts[i].y);
+      dp += 2.0;
+      while(dp <= dq) {
+	/* Point is indicated by its interval and parameter t. */
+	iPts[count].x = (double)i;
+	iPts[count].y =  dp / d;
+	map[count] = mapPtr->map[i];
+	count++;
+	dp += 2.0;
+      }
+    }
+  }
+  iPts[count].x = (double)i;
+  iPts[count].y = 0.0;
+  map[count] = mapPtr->map[i];
+  count++;
+  niPts = count;
+  int result = 0;
+  if (smooth_ == CUBIC)
+    result = naturalParametricSpline(origPts, nOrigPts, &exts, 0, iPts, niPts);
+  else if (smooth_ == CATROM)
+    result = catromParametricSpline(origPts, nOrigPts, iPts, niPts);
+
+  // The spline interpolation failed.  We will fall back to the current
+  // coordinates and do no smoothing (standard line segments)
+  if (!result) {
+    smooth_ = LINEAR;
+    delete [] iPts;
+    delete [] map;
+  }
+  else {
+    delete [] mapPtr->map;
+    mapPtr->map = map;
+    delete [] mapPtr->screenPts;
+    mapPtr->screenPts = iPts;
+    mapPtr->nScreenPts = niPts;
+  }
+}
+
+void LineElement::mapSymbols(MapInfo *mapPtr)
+{
+  Point2d* points = new Point2d[mapPtr->nScreenPts];
+  int *map = new int[mapPtr->nScreenPts];
+
+  Region2d exts;
+  graphPtr_->extents(&exts);
+
+  Point2d *pp;
+  int count = 0;
+  int i;
+  for (pp=mapPtr->screenPts, i=0; i<mapPtr->nScreenPts; i++, pp++) {
+    if (PointInRegion(&exts, pp->x, pp->y)) {
+      points[count].x = pp->x;
+      points[count].y = pp->y;
+      map[count] = mapPtr->map[i];
+      count++;
+    }
+  }
+  symbolPts_.points = points;
+  symbolPts_.length = count;
+  symbolPts_.map = map;
+}
+
+void LineElement::mapActiveSymbols()
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  if (activePts_.points) {
+    delete [] activePts_.points;
+    activePts_.points = NULL;
+  }
+  if (activePts_.map) {
+    delete [] activePts_.map;
+    activePts_.map = NULL;
+  }
+
+  Region2d exts;
+  graphPtr_->extents(&exts);
+
+  Point2d *points = new Point2d[nActiveIndices_];
+  int* map = new int[nActiveIndices_];
+  int np = NUMBEROFPOINTS(ops);
+  int count = 0;
+  if (ops->coords.x && ops->coords.y) {
+    for (int ii=0; ii<nActiveIndices_; ii++) {
+      int iPoint = activeIndices_[ii];
+      if (iPoint >= np)
+	continue;
+
+      double x = ops->coords.x->values_[iPoint];
+      double y = ops->coords.y->values_[iPoint];
+      points[count] = graphPtr_->map2D(x, y, ops->xAxis, ops->yAxis);
+      map[count] = iPoint;
+      if (PointInRegion(&exts, points[count].x, points[count].y)) {
+	count++;
+      }
+    }
+  }
+
+  if (count > 0) {
+    activePts_.points = points;
+    activePts_.map = map;
+  }
+  else {
+    delete [] points;
+    delete [] map;	
+  }
+  activePts_.length = count;
+}
+
+void LineElement::mergePens(LineStyle **styleMap)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  if (Chain_GetLength(ops->stylePalette) < 2) {
+    ChainLink* link = Chain_FirstLink(ops->stylePalette);
+    LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+    stylePtr->symbolPts.length = symbolPts_.length;
+    stylePtr->symbolPts.points = symbolPts_.points;
+    stylePtr->xeb.length = xeb_.length;
+    stylePtr->xeb.segments = xeb_.segments;
+    stylePtr->yeb.length = yeb_.length;
+    stylePtr->yeb.segments = yeb_.segments;
+    return;
+  }
+
+  if (symbolPts_.length > 0) {
+    Point2d* points = new Point2d[symbolPts_.length];
+    int* map = new int[symbolPts_.length];
+    Point2d *pp = points;
+    int* ip = map;
+    for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+	 link = Chain_NextLink(link)) {
+      LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+      stylePtr->symbolPts.points = pp;
+      for (int ii=0; ii<symbolPts_.length; ii++) {
+	int iData = symbolPts_.map[ii];
+	if (styleMap[iData] == stylePtr) {
+	  *pp++ = symbolPts_.points[ii];
+	  *ip++ = iData;
+	}
+      }
+      stylePtr->symbolPts.length = pp - stylePtr->symbolPts.points;
+    }
+    delete [] symbolPts_.points;
+    symbolPts_.points = points;
+    delete [] symbolPts_.map;
+    symbolPts_.map = map;
+  }
+
+  if (xeb_.length > 0) {
+    Segment2d* segments = new Segment2d[xeb_.length];
+    Segment2d *sp = segments;
+    int* map = new int[xeb_.length];
+    int* ip = map;
+    for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+	 link = Chain_NextLink(link)) {
+      LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+      stylePtr->xeb.segments = sp;
+      for (int ii=0; ii<xeb_.length; ii++) {
+	int iData = xeb_.map[ii];
+	if (styleMap[iData] == stylePtr) {
+	  *sp++ = xeb_.segments[ii];
+	  *ip++ = iData;
+	}
+      }
+      stylePtr->xeb.length = sp - stylePtr->xeb.segments;
+    }
+    delete [] xeb_.segments;
+    xeb_.segments = segments;
+    delete [] xeb_.map;
+    xeb_.map = map;
+  }
+
+  if (yeb_.length > 0) {
+    Segment2d* segments = new Segment2d[yeb_.length];
+    Segment2d* sp = segments;
+    int* map = new int [yeb_.length];
+    int* ip = map;
+    for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+	 link = Chain_NextLink(link)) {
+      LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+      stylePtr->yeb.segments = sp;
+      for (int ii=0; ii<yeb_.length; ii++) {
+	int iData = yeb_.map[ii];
+	if (styleMap[iData] == stylePtr) {
+	  *sp++ = yeb_.segments[ii];
+	  *ip++ = iData;
+	}
+      }
+      stylePtr->yeb.length = sp - stylePtr->yeb.segments;
+    }
+    delete [] yeb_.segments;
+    yeb_.segments = segments;
+    delete [] yeb_.map;
+    yeb_.map = map;
+  }
+}
+
+#define CLIP_TOP	(1<<0)
+#define CLIP_BOTTOM	(1<<1)
+#define CLIP_RIGHT	(1<<2)
+#define CLIP_LEFT	(1<<3)
+
+int LineElement::outCode(Region2d *extsPtr, Point2d *p)
+{
+  int code =0;
+  if (p->x > extsPtr->right)
+    code |= CLIP_RIGHT;
+  else if (p->x < extsPtr->left)
+    code |= CLIP_LEFT;
+
+  if (p->y > extsPtr->bottom)
+    code |= CLIP_BOTTOM;
+  else if (p->y < extsPtr->top)
+    code |= CLIP_TOP;
+
+  return code;
+}
+
+int LineElement::clipSegment(Region2d *extsPtr, int code1, int code2,
+			     Point2d *p, Point2d *q)
+{
+  int inside = ((code1 | code2) == 0);
+  int outside = ((code1 & code2) != 0);
+
+  /*
+   * In the worst case, we'll clip the line segment against each of the four
+   * sides of the bounding rectangle.
+   */
+  while ((!outside) && (!inside)) {
+    if (code1 == 0) {
+      Point2d *tmp;
+      int code;
+
+      /* Swap pointers and out codes */
+      tmp = p, p = q, q = tmp;
+      code = code1, code1 = code2, code2 = code;
+    }
+    if (code1 & CLIP_LEFT) {
+      p->y += (q->y - p->y) *
+	(extsPtr->left - p->x) / (q->x - p->x);
+      p->x = extsPtr->left;
+    } else if (code1 & CLIP_RIGHT) {
+      p->y += (q->y - p->y) *
+	(extsPtr->right - p->x) / (q->x - p->x);
+      p->x = extsPtr->right;
+    } else if (code1 & CLIP_BOTTOM) {
+      p->x += (q->x - p->x) *
+	(extsPtr->bottom - p->y) / (q->y - p->y);
+      p->y = extsPtr->bottom;
+    } else if (code1 & CLIP_TOP) {
+      p->x += (q->x - p->x) *
+	(extsPtr->top - p->y) / (q->y - p->y);
+      p->y = extsPtr->top;
+    }
+    code1 = outCode(extsPtr, p);
+
+    inside = ((code1 | code2) == 0);
+    outside = ((code1 & code2) != 0);
+  }
+  return (!inside);
+}
+
+void LineElement::saveTrace(int start, int length, MapInfo* mapPtr)
+{
+  bltTrace* tracePtr  = new bltTrace;
+  Point2d* screenPts = new Point2d[length];
+  int* map = new int[length];
+
+  // Copy the screen coordinates of the trace into the point array
+  if (mapPtr->map) {
+    for (int ii=0, jj=start; ii<length; ii++, jj++) {
+      screenPts[ii].x = mapPtr->screenPts[jj].x;
+      screenPts[ii].y = mapPtr->screenPts[jj].y;
+      map[ii] = mapPtr->map[jj];
+    }
+  } 
+  else {
+    for (int ii=0, jj=start; ii<length; ii++, jj++) {
+      screenPts[ii].x = mapPtr->screenPts[jj].x;
+      screenPts[ii].y = mapPtr->screenPts[jj].y;
+      map[ii] = jj;
+    }
+  }
+  tracePtr->screenPts.length = length;
+  tracePtr->screenPts.points = screenPts;
+  tracePtr->screenPts.map = map;
+  tracePtr->start = start;
+  if (traces_ == NULL)
+    traces_ = new Chain();
+
+  traces_->append(tracePtr);
+}
+
+void LineElement::freeTraces()
+{
+  for (ChainLink* link = Chain_FirstLink(traces_); link;
+       link = Chain_NextLink(link)) {
+    bltTrace* tracePtr = (bltTrace*)Chain_GetValue(link);
+    delete [] tracePtr->screenPts.map;
+    delete [] tracePtr->screenPts.points;
+    delete tracePtr;
+  }
+  delete traces_;
+  traces_ = NULL;
+}
+
+void LineElement::mapTraces(MapInfo *mapPtr)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  Region2d exts;
+  graphPtr_->extents(&exts);
+
+  int count = 1;
+  int code1 = outCode(&exts, mapPtr->screenPts);
+  Point2d* p = mapPtr->screenPts;
+  Point2d* q = p + 1;
+
+  int start;
+  int ii;
+  for (ii=1; ii<mapPtr->nScreenPts; ii++, p++, q++) {
+    Point2d s;
+    s.x = 0;
+    s.y = 0;
+    int code2 = outCode(&exts, q);
+    // Save the coordinates of the last point, before clipping
+    if (code2 != 0)
+      s = *q;
+
+    int broken = BROKEN_TRACE(ops->penDir, p->x, q->x);
+    int offscreen = clipSegment(&exts, code1, code2, p, q);
+    if (broken || offscreen) {
+      // The last line segment is either totally clipped by the plotting
+      // area or the x-direction is wrong, breaking the trace.  Either
+      // way, save information about the last trace (if one exists),
+      // discarding the current line segment
+      if (count > 1) {
+	start = ii - count;
+	saveTrace(start, count, mapPtr);
+	count = 1;
+      }
+    }
+    else {
+      // Add the point to the trace
+      count++;
+
+      // If the last point is clipped, this means that the trace is
+      // broken after this point.  Restore the original coordinate
+      // (before clipping) after saving the trace.
+      if (code2 != 0) {
+	start = ii - (count - 1);
+	saveTrace(start, count, mapPtr);
+	mapPtr->screenPts[ii] = s;
+	count = 1;
+      }
+    }
+    code1 = code2;
+  }
+  if (count > 1) {
+    start = ii - count;
+    saveTrace(start, count, mapPtr);
+  }
+}
+
+void LineElement::mapFillArea(MapInfo *mapPtr)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
+
+  if (fillPts_) {
+    delete [] fillPts_;
+    fillPts_ = NULL;
+    nFillPts_ = 0;
+  }
+  if (mapPtr->nScreenPts < 3)
+    return;
+
+  int np = mapPtr->nScreenPts + 3;
+  Region2d exts;
+  graphPtr_->extents(&exts);
+
+  Point2d* origPts = new Point2d[np];
+  if (gops->inverted) {
+    int i;
+    double minX = (double)ops->yAxis->screenMin_;
+    for (i = 0; i < mapPtr->nScreenPts; i++) {
+      origPts[i].x = mapPtr->screenPts[i].x + 1;
+      origPts[i].y = mapPtr->screenPts[i].y;
+      if (origPts[i].x < minX) {
+	minX = origPts[i].x;
+      }
+    }	
+    // Add edges to make the polygon fill to the bottom of plotting window
+    origPts[i].x = minX;
+    origPts[i].y = origPts[i - 1].y;
+    i++;
+    origPts[i].x = minX;
+    origPts[i].y = origPts[0].y; 
+    i++;
+    origPts[i] = origPts[0];
+  }
+  else {
+    int i;
+    double maxY = (double)ops->yAxis->bottom_;
+    for (i = 0; i < mapPtr->nScreenPts; i++) {
+      origPts[i].x = mapPtr->screenPts[i].x + 1;
+      origPts[i].y = mapPtr->screenPts[i].y;
+      if (origPts[i].y > maxY) {
+	maxY = origPts[i].y;
+      }
+    }	
+    // Add edges to extend the fill polygon to the bottom of plotting window
+    origPts[i].x = origPts[i - 1].x;
+    origPts[i].y = maxY;
+    i++;
+    origPts[i].x = origPts[0].x; 
+    origPts[i].y = maxY;
+    i++;
+    origPts[i] = origPts[0];
+  }
+
+  Point2d *clipPts = new Point2d[np * 3];
+  np = polyRectClip(&exts, origPts, np - 1, clipPts);
+
+  delete [] origPts;
+  if (np < 3)
+    delete [] clipPts;
+  else {
+    fillPts_ = clipPts;
+    nFillPts_ = np;
+  }
+}
+
+void LineElement::reset()
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  freeTraces();
+
+  for (ChainLink* link = Chain_FirstLink(ops->stylePalette); link;
+       link = Chain_NextLink(link)) {
+    LineStyle *stylePtr = (LineStyle*)Chain_GetValue(link);
+    stylePtr->symbolPts.length = 0;
+    stylePtr->xeb.length = 0;
+    stylePtr->yeb.length = 0;
+  }
+
+  if (symbolPts_.points) {
+    delete [] symbolPts_.points;
+    symbolPts_.points = NULL;
+  }
+
+  if (symbolPts_.map)
+    delete [] symbolPts_.map;
+  symbolPts_.map = NULL;
+  symbolPts_.length = 0;
+
+  if (activePts_.points)
+    delete [] activePts_.points;
+  activePts_.points = NULL;
+  activePts_.length = 0;
+
+  if (activePts_.map)
+    delete [] activePts_.map;
+  activePts_.map = NULL;
+
+  if (xeb_.segments)
+    delete [] xeb_.segments;
+  xeb_.segments = NULL;
+  if (xeb_.map)
+    delete [] xeb_.map;
+  xeb_.map = NULL;
+  xeb_.length = 0;
+
+  if (yeb_.segments)
+    delete [] yeb_.segments;
+  yeb_.segments = NULL;
+  if (yeb_.map)
+    delete [] yeb_.map;
+  yeb_.map = NULL;
+  yeb_.length = 0;
+}
+
+void LineElement::mapErrorBars(LineStyle **styleMap)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  Region2d exts;
+  graphPtr_->extents(&exts);
+
+  int nn =0;
+  int np = NUMBEROFPOINTS(ops);
+  if (ops->coords.x && ops->coords.y) {
+    if (ops->xError && (ops->xError->nValues() > 0))
+      nn = MIN(ops->xError->nValues(), np);
+    else
+      if (ops->xHigh && ops->xLow)
+	nn = MIN3(ops->xHigh->nValues(), ops->xLow->nValues(), np);
+  }
+
+  if (nn) {
+    Segment2d* errorBars = new Segment2d[nn * 3];
+    Segment2d* segPtr = errorBars;
+    int* errorToData = new int[nn * 3];
+    int* indexPtr = errorToData;
+
+    for (int ii=0; ii<nn; ii++) {
+      double x = ops->coords.x->values_[ii];
+      double y = ops->coords.y->values_[ii];
+      LineStyle* stylePtr = styleMap[ii];
+
+      if ((isfinite(x)) && (isfinite(y))) {
+	double high;
+	double low;
+	if (ops->xError->nValues() > 0) {
+	  high = x + ops->xError->values_[ii];
+	  low = x - ops->xError->values_[ii];
+	} 
+	else {
+	  high = ops->xHigh ? ops->xHigh->values_[ii] : 0;
+	  low  = ops->xLow ? ops->xLow->values_[ii] : 0;
+	}
+
+	if ((isfinite(high)) && (isfinite(low)))  {
+	  Point2d p = graphPtr_->map2D(high, y, ops->xAxis, ops->yAxis);
+	  Point2d q = graphPtr_->map2D(low, y, ops->xAxis, ops->yAxis);
+	  segPtr->p = p;
+	  segPtr->q = q;
+	  if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = ii;
+	  }
+	  // Left cap
+	  segPtr->p.x = p.x;
+	  segPtr->q.x = p.x;
+	  segPtr->p.y = p.y - stylePtr->errorBarCapWidth;
+	  segPtr->q.y = p.y + stylePtr->errorBarCapWidth;
+	  if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = ii;
+	  }
+	  // Right cap
+	  segPtr->p.x = q.x;
+	  segPtr->q.x = q.x;
+	  segPtr->p.y = q.y - stylePtr->errorBarCapWidth;
+	  segPtr->q.y = q.y + stylePtr->errorBarCapWidth;
+	  if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = ii;
+	  }
+	}
+      }
+    }
+    xeb_.segments = errorBars;
+    xeb_.length = segPtr - errorBars;
+    xeb_.map = errorToData;
+  }
+
+  nn =0;
+  if (ops->coords.x && ops->coords.y) {
+    if (ops->yError && (ops->yError->nValues() > 0))
+      nn = MIN(ops->yError->nValues(), np);
+    else
+      if (ops->yHigh && ops->yLow)
+	nn = MIN3(ops->yHigh->nValues(), ops->yLow->nValues(), np);
+  }
+
+  if (nn) {
+    Segment2d* errorBars = new Segment2d[nn * 3];
+    Segment2d* segPtr = errorBars;
+    int* errorToData = new int[nn * 3];
+    int* indexPtr = errorToData;
+
+    for (int ii=0; ii<nn; ii++) {
+      double x = ops->coords.x->values_[ii];
+      double y = ops->coords.y->values_[ii];
+      LineStyle* stylePtr = styleMap[ii];
+
+      if ((isfinite(x)) && (isfinite(y))) {
+	double high;
+	double low;
+ 	if (ops->yError->nValues() > 0) {
+ 	  high = y + ops->yError->values_[ii];
+ 	  low = y - ops->yError->values_[ii];
+ 	} 
+	else {
+ 	  high = ops->yHigh->values_[ii];
+ 	  low = ops->yLow->values_[ii];
+ 	}
+
+	if ((isfinite(high)) && (isfinite(low)))  {
+	  Point2d p = graphPtr_->map2D(x, high, ops->xAxis, ops->yAxis);
+	  Point2d q = graphPtr_->map2D(x, low, ops->xAxis, ops->yAxis);
+	  segPtr->p = p;
+	  segPtr->q = q;
+	  if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = ii;
+	  }
+	  // Top cap
+	  segPtr->p.y = p.y;
+	  segPtr->q.y = p.y;
+	  segPtr->p.x = p.x - stylePtr->errorBarCapWidth;
+	  segPtr->q.x = p.x + stylePtr->errorBarCapWidth;
+	  if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = ii;
+	  }
+	  // Bottom cap
+	  segPtr->p.y = q.y;
+	  segPtr->q.y = q.y;
+	  segPtr->p.x = q.x - stylePtr->errorBarCapWidth;
+	  segPtr->q.x = q.x + stylePtr->errorBarCapWidth;
+	  if (lineRectClip(&exts, &segPtr->p, &segPtr->q)) {
+	    segPtr++;
+	    *indexPtr++ = ii;
+	  }
+	}
+      }
+    }
+    yeb_.segments = errorBars;
+    yeb_.length = segPtr - errorBars;
+    yeb_.map = errorToData;
+  }
+}
+
+int LineElement::closestTrace()
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  GraphOptions* gops = (GraphOptions*)graphPtr_->ops_;
+  ClosestSearch* searchPtr = &gops->search;
+
+  Point2d closest;
+
+  int iClose = -1;
+  double dMin = searchPtr->dist;
+  closest.x = closest.y = 0;
+  for (ChainLink *link=Chain_FirstLink(traces_); link; 
+       link = Chain_NextLink(link)) {
+    bltTrace *tracePtr = (bltTrace*)Chain_GetValue(link);
+    for (Point2d *p=tracePtr->screenPts.points, 
+	   *pend=p + (tracePtr->screenPts.length - 1); p<pend; p++) {
+      Point2d b;
+      double d;
+      if (searchPtr->along == SEARCH_X)
+	d = distanceToX(searchPtr->x, searchPtr->y, p, p + 1, &b);
+      else if (searchPtr->along == SEARCH_Y)
+	d = distanceToY(searchPtr->x, searchPtr->y, p, p + 1, &b);
+      else
+	d = distanceToLine(searchPtr->x, searchPtr->y, p, p + 1, &b);
+
+      if (d < dMin) {
+	closest = b;
+	iClose = tracePtr->screenPts.map[p-tracePtr->screenPts.points];
+	dMin = d;
+      }
+    }
+  }
+  if (dMin < searchPtr->dist) {
+    searchPtr->dist = dMin;
+    searchPtr->elemPtr = (Element*)this;
+    searchPtr->index = iClose;
+    searchPtr->point = graphPtr_->invMap2D(closest.x, closest.y, 
+					   ops->xAxis, ops->yAxis);
+    return 1;
+  }
+
+  return 0;
+}
+
+void LineElement::closestPoint(ClosestSearch *searchPtr)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+
+  double dMin = searchPtr->dist;
+  int iClose = 0;
+
+  // Instead of testing each data point in graph coordinates, look at the
+  // array of mapped screen coordinates. The advantages are
+  //  1) only examine points that are visible (unclipped), and
+  //  2) the computed distance is already in screen coordinates.
+  int count =0;
+  for (Point2d *pp = symbolPts_.points; count < symbolPts_.length;
+       count++, pp++) {
+    double dx = (double)(searchPtr->x - pp->x);
+    double dy = (double)(searchPtr->y - pp->y);
+    double d;
+    if (searchPtr->along == SEARCH_BOTH)
+      d = hypot(dx, dy);
+    else if (searchPtr->along == SEARCH_X)
+      d = dx;
+    else if (searchPtr->along == SEARCH_Y)
+      d = dy;
+    else
+      continue;
+
+    if (d < dMin) {
+      iClose = symbolPts_.map[count];
+      dMin = d;
+    }
+  }
+  if (dMin < searchPtr->dist) {
+    searchPtr->elemPtr = (Element*)this;
+    searchPtr->dist = dMin;
+    searchPtr->index = iClose;
+    searchPtr->point.x = ops->coords.x->values_[iClose];
+    searchPtr->point.y = ops->coords.y->values_[iClose];
+  }
+}
+
+void LineElement::drawCircle(Display *display, Drawable drawable, 
+			     LinePen* penPtr, 
+			     int nSymbolPts, Point2d *symbolPts, int radius)
+{
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  int count = 0;
+  int s = radius + radius;
+  XArc* arcs = new XArc[nSymbolPts];
+  XArc *ap = arcs;
+  for (Point2d *pp=symbolPts, *pend=pp+nSymbolPts; pp<pend; pp++) {
+    if (DRAW_SYMBOL()) {
+      ap->x = pp->x - radius;
+      ap->y = pp->y - radius;
+      ap->width = (unsigned short)s;
+      ap->height = (unsigned short)s;
+      ap->angle1 = 0;
+      ap->angle2 = 23040;
+      ap++;
+      count++;
+    }
+    symbolCounter_++;
+  }
+
+  for (XArc *ap=arcs, *aend=ap+count; ap<aend; ap++) {
+    if (penOps->symbol.fillGC)
+      XFillArc(display, drawable, penOps->symbol.fillGC, 
+	       ap->x, ap->y, ap->width, ap->height, ap->angle1, ap->angle2);
+
+    if (penOps->symbol.outlineWidth > 0)
+      XDrawArc(display, drawable, penOps->symbol.outlineGC,
+	       ap->x, ap->y, ap->width, ap->height, ap->angle1, ap->angle2);
+  }
+
+  delete [] arcs;
+}
+
+void LineElement::drawSquare(Display *display, Drawable drawable, 
+			     LinePen* penPtr, 
+			     int nSymbolPts, Point2d *symbolPts, int r)
+{
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  int s = r + r;
+  int count =0;
+  XRectangle* rectangles = new XRectangle[nSymbolPts];
+  XRectangle* rp=rectangles; 
+  for (Point2d *pp=symbolPts, *pend=pp+nSymbolPts; pp<pend; pp++) {
+    if (DRAW_SYMBOL()) {
+      rp->x = pp->x - r;
+      rp->y = pp->y - r;
+      rp->width = (unsigned short)s;
+      rp->height = (unsigned short)s;
+      rp++;
+      count++;
+    }
+    symbolCounter_++;
+  }
+
+  for (XRectangle *rp=rectangles, *rend=rp+count; rp<rend; rp ++) {
+    if (penOps->symbol.fillGC)
+      XFillRectangle(display, drawable, penOps->symbol.fillGC,
+		     rp->x, rp->y, rp->width, rp->height);
+
+    if (penOps->symbol.outlineWidth > 0)
+      XDrawRectangle(display, drawable, penOps->symbol.outlineGC,
+		     rp->x, rp->y, rp->width, rp->height);
+  }
+
+  delete [] rectangles;
+}
+
+void LineElement::drawSCross(Display* display, Drawable drawable, 
+			     LinePen* penPtr, 
+			     int nSymbolPts, Point2d* symbolPts, int r2)
+{
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  XPoint pattern[4];
+  if (penOps->symbol.type == SYMBOL_SCROSS) {
+    r2 = (double)r2 * M_SQRT1_2;
+    pattern[3].y = pattern[2].x = pattern[0].x = pattern[0].y = -r2;
+    pattern[3].x = pattern[2].y = pattern[1].y = pattern[1].x = r2;
+  }
+  else {
+    pattern[0].y = pattern[1].y = pattern[2].x = pattern[3].x = 0;
+    pattern[0].x = pattern[2].y = -r2;
+    pattern[1].x = pattern[3].y = r2;
+  }
+
+  for (Point2d *pp=symbolPts, *endp=pp+nSymbolPts; pp<endp; pp++) {
+    if (DRAW_SYMBOL()) {
+      int rndx = pp->x;
+      int rndy = pp->y;
+      XDrawLine(graphPtr_->display_, drawable, penOps->symbol.outlineGC,
+		pattern[0].x + rndx, pattern[0].y + rndy,
+		pattern[1].x + rndx, pattern[1].y + rndy);
+      XDrawLine(graphPtr_->display_, drawable, penOps->symbol.outlineGC,
+		pattern[2].x + rndx, pattern[2].y + rndy,
+		pattern[3].x + rndx, pattern[3].y + rndy);
+    }
+  }
+}
+
+void LineElement::drawCross(Display *display, Drawable drawable, 
+			    LinePen* penPtr, 
+			    int nSymbolPts, Point2d *symbolPts, int r2)
+{
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  /*
+   *          2   3       The plus/cross symbol is a closed polygon
+   *                      of 12 points. The diagram to the left
+   *    0,12  1   4    5  represents the positions of the points
+   *           x,y        which are computed below. The extra
+   *     11  10   7    6  (thirteenth) point connects the first and
+   *                      last points.
+   *          9   8
+   */
+  int d = (r2 / 3);
+  XPoint pattern[13];
+  pattern[0].x = pattern[11].x = pattern[12].x = -r2;
+  pattern[2].x = pattern[1].x = pattern[10].x = pattern[9].x = -d;
+  pattern[3].x = pattern[4].x = pattern[7].x = pattern[8].x = d;
+  pattern[5].x = pattern[6].x = r2;
+  pattern[2].y = pattern[3].y = -r2;
+  pattern[0].y = pattern[1].y = pattern[4].y = pattern[5].y =
+    pattern[12].y = -d;
+  pattern[11].y = pattern[10].y = pattern[7].y = pattern[6].y = d;
+  pattern[9].y = pattern[8].y = r2;
+
+  if (penOps->symbol.type == SYMBOL_CROSS) {
+    // For the cross symbol, rotate the points by 45 degrees
+    for (int ii=0; ii<12; ii++) {
+      double dx = (double)pattern[ii].x * M_SQRT1_2;
+      double dy = (double)pattern[ii].y * M_SQRT1_2;
+      pattern[ii].x = dx - dy;
+      pattern[ii].y = dx + dy;
+    }
+    pattern[12] = pattern[0];
+  }
+
+  int count = 0;
+  XPoint* polygon = new XPoint[nSymbolPts*13];
+  XPoint* xpp = polygon;
+  for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++) {
+    if (DRAW_SYMBOL()) {
+      int rndx = pp->x;
+      int rndy = pp->y;
+      for (int ii=0; ii<13; ii++) {
+	xpp->x = pattern[ii].x + rndx;
+	xpp->y = pattern[ii].y + rndy;
+	xpp++;
+      }
+      count++;
+    }
+    symbolCounter_++;
+  }
+
+  if (penOps->symbol.fillGC) {
+    XPoint* xpp = polygon;
+    for (int ii=0; ii<count; ii++, xpp += 13)
+      XFillPolygon(graphPtr_->display_, drawable, 
+		   penOps->symbol.fillGC, xpp, 13, Complex, 
+		   CoordModeOrigin);
+  }
+
+  if (penOps->symbol.outlineWidth > 0) {
+    XPoint*xpp = polygon;
+    for (int ii=0; ii<count; ii++, xpp += 13)
+      XDrawLines(graphPtr_->display_, drawable, 
+		 penOps->symbol.outlineGC, xpp, 13, CoordModeOrigin);
+  }
+
+  delete [] polygon;
+}
+
+void LineElement::drawDiamond(Display *display, Drawable drawable, 
+			      LinePen* penPtr, 
+			      int nSymbolPts, Point2d *symbolPts, int r1)
+{
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  /*
+   *                      The plus symbol is a closed polygon
+   *            1         of 4 points. The diagram to the left
+   *                      represents the positions of the points
+   *       0,4 x,y  2     which are computed below. The extra
+   *                      (fifth) point connects the first and
+   *            3         last points.
+   */
+  XPoint pattern[5];
+  pattern[1].y = pattern[0].x = -r1;
+  pattern[2].y = pattern[3].x = pattern[0].y = pattern[1].x = 0;
+  pattern[3].y = pattern[2].x = r1;
+  pattern[4] = pattern[0];
+
+  int count = 0;
+  XPoint* polygon = new XPoint[nSymbolPts*5];
+  XPoint* xpp = polygon;
+  for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++) {
+    if (DRAW_SYMBOL()) {
+      int rndx = pp->x;
+      int rndy = pp->y;
+      for (int ii=0; ii<5; ii++) {
+	xpp->x = pattern[ii].x + rndx;
+	xpp->y = pattern[ii].y + rndy;
+	xpp++;
+      }
+      count++;
+    }
+    symbolCounter_++;
+  }
+
+  if (penOps->symbol.fillGC) {
+    XPoint* xpp = polygon;
+    for (int ii=0; ii<count; ii++, xpp += 5)
+      XFillPolygon(graphPtr_->display_, drawable, 
+		   penOps->symbol.fillGC, xpp, 5, Convex, CoordModeOrigin);
+  }
+
+  if (penOps->symbol.outlineWidth > 0) {
+    XPoint* xpp = polygon;
+    for (int ii=0; ii<count; ii++, xpp += 5)
+      XDrawLines(graphPtr_->display_, drawable, 
+		 penOps->symbol.outlineGC, xpp, 5, CoordModeOrigin);
+  }
+
+  delete [] polygon;
+}
+
+#define B_RATIO		1.3467736870885982
+#define TAN30		0.57735026918962573
+#define COS30		0.86602540378443871
+void LineElement::drawArrow(Display *display, Drawable drawable, 
+			    LinePen* penPtr, 
+			    int nSymbolPts, Point2d *symbolPts, int size)
+{
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  double b = size * B_RATIO * 0.7;
+  int b2 = b * 0.5;
+  int h2 = TAN30 * b2;
+  int h1 = b2 / COS30;
+  /*
+   *                      The triangle symbol is a closed polygon
+   *           0,3         of 3 points. The diagram to the left
+   *                      represents the positions of the points
+   *           x,y        which are computed below. The extra
+   *                      (fourth) point connects the first and
+   *      2           1   last points.
+   */
+
+  XPoint pattern[4];
+  if (penOps->symbol.type == SYMBOL_ARROW) {
+    pattern[3].x = pattern[0].x = 0;
+    pattern[3].y = pattern[0].y = h1;
+    pattern[1].x = b2;
+    pattern[2].y = pattern[1].y = -h2;
+    pattern[2].x = -b2;
+  } else {
+    pattern[3].x = pattern[0].x = 0;
+    pattern[3].y = pattern[0].y = -h1;
+    pattern[1].x = b2;
+    pattern[2].y = pattern[1].y = h2;
+    pattern[2].x = -b2;
+  }
+
+  int count = 0;
+  XPoint* polygon = new XPoint[nSymbolPts*4];
+  XPoint* xpp = polygon;
+  for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++) {
+    if (DRAW_SYMBOL()) {
+      int rndx = pp->x;
+      int rndy = pp->y;
+      for (int ii=0; ii<4; ii++) {
+	xpp->x = pattern[ii].x + rndx;
+	xpp->y = pattern[ii].y + rndy;
+	xpp++;
+      }
+      count++;
+    }
+    symbolCounter_++;
+  }
+
+  if (penOps->symbol.fillGC) {
+    XPoint* xpp = polygon;
+    for (int ii=0; ii<count; ii++, xpp += 4)
+      XFillPolygon(graphPtr_->display_, drawable, 
+		   penOps->symbol.fillGC, xpp, 4, Convex, CoordModeOrigin);
+  }
+
+  if (penOps->symbol.outlineWidth > 0) {
+    XPoint* xpp = polygon;
+    for (int ii=0; ii<count; ii++, xpp += 4)
+      XDrawLines(graphPtr_->display_, drawable, 
+		 penOps->symbol.outlineGC, xpp, 4, CoordModeOrigin);
+  }
+
+  delete [] polygon;
+}
+
+#define S_RATIO		0.886226925452758
+void LineElement::drawSymbols(Drawable drawable, LinePen* penPtr, int size,
+			      int nSymbolPts, Point2d* symbolPts)
+{
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops();
+
+  if (size < 3) {
+    if (penOps->symbol.fillGC) {
+      for (Point2d *pp = symbolPts, *endp = pp + nSymbolPts; pp < endp; pp++)
+	XDrawLine(graphPtr_->display_, drawable, penOps->symbol.fillGC, 
+		  pp->x, pp->y, pp->x+1, pp->y+1);
+    }
+    return;
+  }
+
+  int r1 = (int)ceil(size * 0.5);
+  int r2 = (int)ceil(size * S_RATIO * 0.5);
+
+  switch (penOps->symbol.type) {
+  case SYMBOL_NONE:
+    break;
+  case SYMBOL_SQUARE:
+    drawSquare(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r2);
+    break;
+  case SYMBOL_CIRCLE:
+    drawCircle(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r1);
+    break;
+  case SYMBOL_SPLUS:
+  case SYMBOL_SCROSS:
+    drawSCross(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r2);
+    break;
+  case SYMBOL_PLUS:
+  case SYMBOL_CROSS:
+    drawCross(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r2);
+    break;
+  case SYMBOL_DIAMOND:
+    drawDiamond(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,r1);
+    break;
+  case SYMBOL_TRIANGLE:
+  case SYMBOL_ARROW:
+    drawArrow(graphPtr_->display_, drawable, penPtr, nSymbolPts,symbolPts,size);
+    break;
+  }
+}
+
+void LineElement::drawTraces(Drawable drawable, LinePen* penPtr)
+{
+  for (ChainLink* link = Chain_FirstLink(traces_); link;
+       link = Chain_NextLink(link)) {
+    bltTrace* tracePtr = (bltTrace*)Chain_GetValue(link);
+
+    int count = tracePtr->screenPts.length; 
+    XPoint* points = new XPoint[count];
+    XPoint*xpp = points;
+    for (int ii=0; ii<count; ii++, xpp++) {
+      xpp->x = tracePtr->screenPts.points[ii].x;
+      xpp->y = tracePtr->screenPts.points[ii].y;
+    }
+    XDrawLines(graphPtr_->display_, drawable, penPtr->traceGC_, points, 
+	       count, CoordModeOrigin);
+    delete [] points;
+  }
+}
+
+void LineElement::drawValues(Drawable drawable, LinePen* penPtr, 
+			     int length, Point2d *points, int *map)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
+
+  char string[TCL_DOUBLE_SPACE * 2 + 2];
+  const char* fmt = pops->valueFormat;
+  if (fmt == NULL)
+    fmt = "%g";
+  TextStyle ts(graphPtr_, &pops->valueStyle);
+
+  double* xval = ops->coords.x->values_;
+  double* yval = ops->coords.y->values_;
+  int count = 0;
+
+  for (Point2d *pp = points, *endp = points + length; pp < endp; pp++) {
+    double x = xval[map[count]];
+    double y = yval[map[count]];
+    count++;
+    if (pops->valueShow == SHOW_X)
+      snprintf(string, TCL_DOUBLE_SPACE, fmt, x); 
+    else if (pops->valueShow == SHOW_Y)
+      snprintf(string, TCL_DOUBLE_SPACE, fmt, y); 
+    else if (pops->valueShow == SHOW_BOTH) {
+      snprintf(string, TCL_DOUBLE_SPACE, fmt, x);
+      strcat(string, ",");
+      snprintf(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
+    }
+
+    ts.drawText(drawable, string, pp->x, pp->y);
+  } 
+}
+
+void LineElement::printSymbols(PSOutput* psPtr, LinePen* penPtr, int size,
+			       int nSymbolPts, Point2d *symbolPts)
+{
+  LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
+
+  double symbolSize;
+
+  // Set line and foreground attributes
+  XColor* fillColor = pops->symbol.fillColor;
+  if (!fillColor)
+    fillColor = pops->traceColor;
+
+  XColor* outlineColor = pops->symbol.outlineColor;
+  if (!outlineColor)
+    outlineColor = pops->traceColor;
+
+  if (pops->symbol.type == SYMBOL_NONE)
+    psPtr->setLineAttributes(pops->traceColor, pops->traceWidth + 2,
+			     &pops->traceDashes, CapButt, JoinMiter);
+  else {
+    psPtr->setLineWidth(pops->symbol.outlineWidth);
+    psPtr->setDashes(NULL);
+  }
+
+  // build DrawSymbolProc
+  psPtr->append("\n/DrawSymbolProc {\n");
+  switch (pops->symbol.type) {
+  case SYMBOL_NONE:
+    break;
+  default:
+    psPtr->append("  ");
+    psPtr->setBackground(fillColor);
+    psPtr->append("  gsave fill grestore\n");
+
+    if (pops->symbol.outlineWidth > 0) {
+      psPtr->append("  ");
+      psPtr->setForeground(outlineColor);
+      psPtr->append("  stroke\n");
+    }
+    break;
+  }
+  psPtr->append("} def\n\n");
+
+  // set size
+  symbolSize = (double)size;
+  switch (pops->symbol.type) {
+  case SYMBOL_SQUARE:
+  case SYMBOL_CROSS:
+  case SYMBOL_PLUS:
+  case SYMBOL_SCROSS:
+  case SYMBOL_SPLUS:
+    symbolSize = (double)size * S_RATIO;
+    break;
+  case SYMBOL_TRIANGLE:
+  case SYMBOL_ARROW:
+    symbolSize = (double)size * 0.7;
+    break;
+  case SYMBOL_DIAMOND:
+    symbolSize = (double)size * M_SQRT1_2;
+    break;
+
+  default:
+    break;
+  }
+
+  int count =0;
+  for (Point2d *pp=symbolPts, *endp=symbolPts + nSymbolPts; pp < endp; pp++) {
+    if (DRAW_SYMBOL()) {
+      psPtr->format("%g %g %g %s\n", pp->x, pp->y, symbolSize, 
+		    symbolMacros[pops->symbol.type]);
+      count++;
+    }
+    symbolCounter_++;
+  }
+}
+
+void LineElement::setLineAttributes(PSOutput* psPtr, LinePen* penPtr)
+{
+  LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
+
+  psPtr->setLineAttributes(pops->traceColor, pops->traceWidth, 
+			   &pops->traceDashes, CapButt, JoinMiter);
+
+  if ((LineIsDashed(pops->traceDashes)) && 
+      (pops->traceOffColor)) {
+    psPtr->append("/DashesProc {\n  gsave\n    ");
+    psPtr->setBackground(pops->traceOffColor);
+    psPtr->append("    ");
+    psPtr->setDashes(NULL);
+    psPtr->append("stroke\n  grestore\n} def\n");
+  } else {
+    psPtr->append("/DashesProc {} def\n");
+  }
+}
+
+void LineElement::printTraces(PSOutput* psPtr, LinePen* penPtr)
+{
+  setLineAttributes(psPtr, penPtr);
+  for (ChainLink* link = Chain_FirstLink(traces_); link; 
+       link = Chain_NextLink(link)) {
+    bltTrace *tracePtr = (bltTrace*)Chain_GetValue(link);
+    if (tracePtr->screenPts.length > 0) {
+      psPtr->append("% start trace\n");
+      psPtr->printMaxPolyline(tracePtr->screenPts.points, 
+			     tracePtr->screenPts.length);
+      psPtr->append("% end trace\n");
+    }
+  }
+}
+
+void LineElement::printValues(PSOutput* psPtr, LinePen* penPtr, 
+			      int nSymbolPts, Point2d *symbolPts, 
+			      int *pointToData)
+{
+  LineElementOptions* ops = (LineElementOptions*)ops_;
+  LinePenOptions* pops = (LinePenOptions*)penPtr->ops();
+
+  const char* fmt = pops->valueFormat;
+  if (fmt == NULL)
+    fmt = "%g";
+  TextStyle ts(graphPtr_, &pops->valueStyle);
+
+  int count = 0;
+  for (Point2d *pp=symbolPts, *endp=symbolPts + nSymbolPts; pp < endp; pp++) {
+    double x = ops->coords.x->values_[pointToData[count]];
+    double y = ops->coords.y->values_[pointToData[count]];
+    count++;
+
+    char string[TCL_DOUBLE_SPACE * 2 + 2];
+    if (pops->valueShow == SHOW_X)
+      snprintf(string, TCL_DOUBLE_SPACE, fmt, x); 
+    else if (pops->valueShow == SHOW_Y)
+      snprintf(string, TCL_DOUBLE_SPACE, fmt, y); 
+    else if (pops->valueShow == SHOW_BOTH) {
+      snprintf(string, TCL_DOUBLE_SPACE, fmt, x);
+      strcat(string, ",");
+      snprintf(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
+    }
+
+    ts.printText(psPtr, string, pp->x, pp->y);
+  } 
+}
+
+