*** empty log message ***

1 files changed, 782 insertions, 722 deletions

diff --git a/src/bltGrElemLine.C b/src/bltGrElemLine.C
index b894fd6..f0cb175 100644
--- a/src/bltGrElemLine.C
+++ b/src/bltGrElemLine.C
@@ -154,128 +154,139 @@ extern Tk_ObjCustomOption yAxisObjOption;
 
 static Tk_OptionSpec optionSpecs[] = {
   {TK_OPTION_CUSTOM, "-activepen", "activePen", "ActivePen",
-   "activeLine", -1, Tk_Offset(LineElement, activePenPtr), 
+   "activeLine", -1, Tk_Offset(LineElementOptions, activePenPtr), 
    TK_OPTION_NULL_OK, &linePenObjOption, 0},
   {TK_OPTION_COLOR, "-areaforeground", "areaForeground", "AreaForeground",
-   NULL, -1, Tk_Offset(LineElement, fillFgColor), TK_OPTION_NULL_OK, NULL, 0},
+   NULL, -1, Tk_Offset(LineElementOptions, fillFgColor), 
+   TK_OPTION_NULL_OK, NULL, 0},
   {TK_OPTION_BORDER, "-areabackground", "areaBackground", "AreaBackground",
-   NULL, -1, Tk_Offset(LineElement, fillBg), 
+   NULL, -1, Tk_Offset(LineElementOptions, fillBg), 
    TK_OPTION_NULL_OK, NULL, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-bindtags", "bindTags", "BindTags", 
-   "all", -1, Tk_Offset(LineElement, obj.tags), 
+   "all", -1, Tk_Offset(LineElementOptions, tags), 
    TK_OPTION_NULL_OK, &listObjOption, 0},
   {TK_OPTION_COLOR, "-color", "color", "Color", 
-   STD_NORMAL_FOREGROUND, -1, Tk_Offset(LineElement, builtinPen.traceColor),
+   STD_NORMAL_FOREGROUND, -1, 
+   Tk_Offset(LineElementOptions, builtinPen.traceColor),
    0, NULL, 0},
   {TK_OPTION_CUSTOM, "-dashes", "dashes", "Dashes", 
-   NULL, -1, Tk_Offset(LineElement, builtinPen.traceDashes), 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.traceDashes), 
    TK_OPTION_NULL_OK, &dashesObjOption, 0},
   {TK_OPTION_CUSTOM, "-data", "data", "Data", 
-   NULL, -1, Tk_Offset(LineElement, coords),
+   NULL, -1, Tk_Offset(LineElementOptions, coords),
    TK_OPTION_NULL_OK, &pairsObjOption, MAP_ITEM},
   {TK_OPTION_COLOR, "-errorbarcolor", "errorBarColor", "ErrorBarColor",
-   NULL, -1, Tk_Offset(LineElement, builtinPen.errorBarColor), 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.errorBarColor), 
    TK_OPTION_NULL_OK, NULL, 0},
   {TK_OPTION_PIXELS,"-errorbarwidth", "errorBarWidth", "ErrorBarWidth",
-   "1", -1, Tk_Offset(LineElement, builtinPen.errorBarLineWidth), 0, NULL, 0},
+   "1", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarLineWidth),
+   0, NULL, 0},
   {TK_OPTION_PIXELS, "-errorbarcap", "errorBarCap", "ErrorBarCap", 
-   "2", -1, Tk_Offset(LineElement, builtinPen.errorBarCapWidth), 0, NULL, 0},
+   "2", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarCapWidth),
+   0, NULL, 0},
   {TK_OPTION_COLOR, "-fill", "fill", "Fill", 
-   NULL, -1, Tk_Offset(LineElement, builtinPen.symbol.fillColor), 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.symbol.fillColor), 
    TK_OPTION_NULL_OK, NULL, 0},
   {TK_OPTION_BOOLEAN, "-hide", "hide", "Hide", 
-   "no", -1, Tk_Offset(LineElement, hide), 0, NULL, MAP_ITEM},
+   "no", -1, Tk_Offset(LineElementOptions, hide), 0, NULL, MAP_ITEM},
   {TK_OPTION_STRING, "-label", "label", "Label", 
-   NULL, -1, Tk_Offset(LineElement, label), 
+   NULL, -1, Tk_Offset(LineElementOptions, label), 
    TK_OPTION_NULL_OK | TK_OPTION_DONT_SET_DEFAULT, NULL, MAP_ITEM},
   {TK_OPTION_RELIEF, "-legendrelief", "legendRelief", "LegendRelief",
-   "flat", -1, Tk_Offset(LineElement, legendRelief), 0, NULL, 0},
+   "flat", -1, Tk_Offset(LineElementOptions, legendRelief), 0, NULL, 0},
   {TK_OPTION_PIXELS, "-linewidth", "lineWidth", "LineWidth",
-   "1", -1, Tk_Offset(LineElement, builtinPen.traceWidth), 0, NULL, 0},
+   "1", -1, Tk_Offset(LineElementOptions, builtinPen.traceWidth),
+   0, NULL, 0},
   {TK_OPTION_CUSTOM, "-mapx", "mapX", "MapX",
-   "x", -1, Tk_Offset(LineElement, axes.x), 0, &xAxisObjOption, MAP_ITEM},
+   "x", -1, Tk_Offset(LineElementOptions, axes.x),
+   0, &xAxisObjOption, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-mapy", "mapY", "MapY",
-   "y", -1, Tk_Offset(LineElement, axes.y), 0, &yAxisObjOption, MAP_ITEM},
+   "y", -1, Tk_Offset(LineElementOptions, axes.y),
+   0, &yAxisObjOption, MAP_ITEM},
   {TK_OPTION_INT, "-maxsymbols", "maxSymbols", "MaxSymbols",
-   "0", -1, Tk_Offset(LineElement, reqMaxSymbols), 0, NULL, 0},
+   "0", -1, Tk_Offset(LineElementOptions, reqMaxSymbols), 0, NULL, 0},
   {TK_OPTION_COLOR, "-offdash", "offDash", "OffDash", 
-   NULL, -1, Tk_Offset(LineElement, builtinPen.traceOffColor),
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.traceOffColor),
    TK_OPTION_NULL_OK, NULL, 0},
   {TK_OPTION_COLOR, "-outline", "outline", "Outline", 
-   NULL, -1, Tk_Offset(LineElement, builtinPen.symbol.outlineColor), 
+   NULL, -1, Tk_Offset(LineElementOptions, builtinPen.symbol.outlineColor), 
    TK_OPTION_NULL_OK, NULL,0},
   {TK_OPTION_PIXELS, "-outlinewidth", "outlineWidth", "OutlineWidth",
-   "1", -1, Tk_Offset(LineElement, builtinPen.symbol.outlineWidth), 0, NULL, 0},
+   "1", -1, Tk_Offset(LineElementOptions, builtinPen.symbol.outlineWidth),
+   0, NULL, 0},
   {TK_OPTION_CUSTOM, "-pen", "pen", "Pen",
-   NULL, -1, Tk_Offset(LineElement, normalPenPtr), 
+   NULL, -1, Tk_Offset(LineElementOptions, normalPenPtr), 
    TK_OPTION_NULL_OK, &linePenObjOption, 0},
   {TK_OPTION_PIXELS, "-pixels", "pixels", "Pixels", 
-   "0.1i", -1, Tk_Offset(LineElement, builtinPen.symbol.size), 
+   "0.1i", -1, Tk_Offset(LineElementOptions, builtinPen.symbol.size), 
    0, NULL, MAP_ITEM},
   {TK_OPTION_DOUBLE, "-reduce", "reduce", "Reduce",
-   "0", -1, Tk_Offset(LineElement, rTolerance), 0, NULL, 0},
+   "0", -1, Tk_Offset(LineElementOptions, rTolerance), 0, NULL, 0},
   {TK_OPTION_BOOLEAN, "-scalesymbols", "scaleSymbols", "ScaleSymbols",
-   "yes", -1, Tk_Offset(LineElement, scaleSymbols), 
+   "yes", -1, Tk_Offset(LineElementOptions, scaleSymbols), 
    0, NULL, (MAP_ITEM | SCALE_SYMBOL)},
   {TK_OPTION_STRING_TABLE, "-showerrorbars", "showErrorBars", "ShowErrorBars",
-   "both", -1, Tk_Offset(LineElement, builtinPen.errorBarShow), 
+   "both", -1, Tk_Offset(LineElementOptions, builtinPen.errorBarShow), 
    0, &fillObjOption, 0},
   {TK_OPTION_STRING_TABLE, "-showvalues", "showValues", "ShowValues",
-   "none", -1, Tk_Offset(LineElement, builtinPen.valueShow), 
+   "none", -1, Tk_Offset(LineElementOptions, builtinPen.valueShow), 
    0, &fillObjOption, 0},
   {TK_OPTION_STRING_TABLE, "-smooth", "smooth", "Smooth", 
-   "linear", -1, Tk_Offset(LineElement, reqSmooth), 
+   "linear", -1, Tk_Offset(LineElementOptions, reqSmooth), 
    0, &smoothObjOption, MAP_ITEM},
-  {TK_OPTION_STRING_TABLE, "-state", "state", "State", 
-   "normal", -1, Tk_Offset(LineElement, state), 0, &stateObjOption, 0},
   {TK_OPTION_CUSTOM, "-styles", "styles", "Styles",
-   "", -1, Tk_Offset(LineElement, stylePalette), 0, &styleObjOption, 0},
+   "", -1, Tk_Offset(LineElementOptions, stylePalette), 0, &styleObjOption, 0},
   {TK_OPTION_CUSTOM, "-symbol", "symbol", "Symbol",
-   "none", -1, Tk_Offset(LineElement, builtinPen.symbol), 
+   "none", -1, Tk_Offset(LineElementOptions, builtinPen.symbol), 
    0, &symbolObjOption, 0},
   {TK_OPTION_STRING_TABLE, "-trace", "trace", "Trace",
-   "both", -1, Tk_Offset(LineElement, penDir), 0, &penDirObjOption, MAP_ITEM},
+   "both", -1, Tk_Offset(LineElementOptions, penDir), 
+   0, &penDirObjOption, MAP_ITEM},
   {TK_OPTION_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor",
-   "s", -1, Tk_Offset(LineElement, builtinPen.valueStyle.anchor), 0, NULL, 0},
+   "s", -1, Tk_Offset(LineElementOptions, builtinPen.valueStyle.anchor),
+   0, NULL, 0},
   {TK_OPTION_COLOR, "-valuecolor", "valueColor", "ValueColor",
-   STD_NORMAL_FOREGROUND,-1,Tk_Offset(LineElement, builtinPen.valueStyle.color),
+   STD_NORMAL_FOREGROUND,-1,
+   Tk_Offset(LineElementOptions, builtinPen.valueStyle.color),
    0, NULL, 0},
   {TK_OPTION_FONT, "-valuefont", "valueFont", "ValueFont",
-   STD_FONT_SMALL, -1, Tk_Offset(LineElement, builtinPen.valueStyle.font),
+   STD_FONT_SMALL, -1, 
+   Tk_Offset(LineElementOptions, builtinPen.valueStyle.font),
    0, NULL, 0},
   {TK_OPTION_STRING, "-valueformat", "valueFormat", "ValueFormat",
-   "%g", -1, Tk_Offset(LineElement, builtinPen.valueFormat), 
+   "%g", -1, Tk_Offset(LineElementOptions, builtinPen.valueFormat), 
    TK_OPTION_NULL_OK, NULL, 0},
   {TK_OPTION_DOUBLE, "-valuerotate", "valueRotate", "ValueRotate",
-   "0", -1, Tk_Offset(LineElement, builtinPen.valueStyle.angle), 0, NULL, 0},
+   "0", -1, Tk_Offset(LineElementOptions, builtinPen.valueStyle.angle),
+   0, NULL, 0},
   {TK_OPTION_CUSTOM, "-weights", "weights", "Weights",
-   NULL, -1, Tk_Offset(LineElement, w), 
+   NULL, -1, Tk_Offset(LineElementOptions, w), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_SYNONYM, "-x", NULL, NULL, NULL, -1, 0, 0, "-xdata", 0},
   {TK_OPTION_CUSTOM, "-xdata", "xData", "XData", 
-   NULL, -1, Tk_Offset(LineElement, coords.x), 
+   NULL, -1, Tk_Offset(LineElementOptions, coords.x), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-xerror", "xError", "XError", 
-   NULL, -1, Tk_Offset(LineElement, xError), 
+   NULL, -1, Tk_Offset(LineElementOptions, xError), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-xhigh", "xHigh", "XHigh", 
-   NULL, -1, Tk_Offset(LineElement, xHigh), 
+   NULL, -1, Tk_Offset(LineElementOptions, xHigh), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-xlow", "xLow", "XLow", 
-   NULL, -1, Tk_Offset(LineElement, xLow), 
+   NULL, -1, Tk_Offset(LineElementOptions, xLow), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_SYNONYM, "-y", NULL, NULL, NULL, -1, 0, 0, "-ydata", 0},
   {TK_OPTION_CUSTOM, "-ydata", "yData", "YData", 
-   NULL, -1, Tk_Offset(LineElement, coords.y), 
+   NULL, -1, Tk_Offset(LineElementOptions, coords.y), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-yerror", "yError", "YError", 
-   NULL, -1, Tk_Offset(LineElement, yError), 
+   NULL, -1, Tk_Offset(LineElementOptions, yError), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-yhigh", "yHigh", "YHigh",
-   NULL, -1, Tk_Offset(LineElement, yHigh), 
+   NULL, -1, Tk_Offset(LineElementOptions, yHigh), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_CUSTOM, "-ylow", "yLow", "YLow", 
-   NULL, -1, Tk_Offset(LineElement, yLow), 
+   NULL, -1, Tk_Offset(LineElementOptions, yLow), 
    TK_OPTION_NULL_OK, &valuesObjOption, MAP_ITEM},
   {TK_OPTION_END, NULL, NULL, NULL, NULL, -1, 0, 0, NULL, 0}
 };
@@ -284,85 +295,88 @@ static Tk_OptionSpec optionSpecs[] = {
 
 Element* Blt_LineElement(Graph* graphPtr)
 {
-  LineElement* elemPtr = (LineElement*)calloc(1, sizeof(LineElement));
-  elemPtr->ops = (LineElementOptions*)calloc(1, sizeof(LineElementOptions));
-  elemPtr->procsPtr = &lineProcs;
+  LineElement* lePtr = (LineElement*)calloc(1, sizeof(LineElement));
+  lePtr->ops = (LineElementOptions*)calloc(1, sizeof(LineElementOptions));
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+  ops->elemPtr = (Element*)lePtr;
 
-  elemPtr->builtinPenPtr = &elemPtr->builtinPen;
-  elemPtr->builtinPen.ops = 
-    &(((LineElementOptions*)(elemPtr->ops))->builtinPenOps);
-  elemPtr->builtinPen.manageOptions =0;
+  lePtr->procsPtr = &lineProcs;
+  ops->builtinPenPtr = &lePtr->builtinPen;
+  lePtr->builtinPen.ops =&ops->builtinPen;
+  lePtr->builtinPen.manageOptions =0;
 
-  InitLinePen(graphPtr, elemPtr->builtinPenPtr, "builtin");
-  Tk_InitOptions(graphPtr->interp, (char*)elemPtr->builtinPenPtr,
-		 elemPtr->builtinPenPtr->optionTable, graphPtr->tkwin);
+  InitLinePen(graphPtr, &lePtr->builtinPen, "builtin");
+  Tk_InitOptions(graphPtr->interp, (char*)&(ops->builtinPen),
+		 lePtr->builtinPen.optionTable, graphPtr->tkwin);
 
-  elemPtr->optionTable = Tk_CreateOptionTable(graphPtr->interp, optionSpecs);
+  lePtr->optionTable = Tk_CreateOptionTable(graphPtr->interp, optionSpecs);
 
-  elemPtr->flags = SCALE_SYMBOL;
-  return (Element*)elemPtr;
+  lePtr->flags = SCALE_SYMBOL;
+  return (Element*)lePtr;
 }
 
-static void DestroyLineProc(Graph* graphPtr, Element* basePtr)
+static void DestroyLineProc(Graph* graphPtr, Element* elemPtr)
 {
-  LineElement* elemPtr = (LineElement*)basePtr;
+  LineElement* lePtr = (LineElement*)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
-  DestroyLinePenProc(graphPtr, (Pen *)&elemPtr->builtinPen);
-  if (elemPtr->activePenPtr)
-    Blt_FreePen((Pen *)elemPtr->activePenPtr);
-  if (elemPtr->normalPenPtr)
-    Blt_FreePen((Pen *)elemPtr->normalPenPtr);
+  DestroyLinePenProc(graphPtr, (Pen *)&lePtr->builtinPen);
+  if (ops->activePenPtr)
+    Blt_FreePen((Pen *)ops->activePenPtr);
+  if (ops->normalPenPtr)
+    Blt_FreePen((Pen *)ops->normalPenPtr);
 
-  ResetLine(elemPtr);
-  if (elemPtr->stylePalette) {
-    Blt_FreeStylePalette(elemPtr->stylePalette);
-    Blt_Chain_Destroy(elemPtr->stylePalette);
+  ResetLine(lePtr);
+  if (ops->stylePalette) {
+    Blt_FreeStylePalette(ops->stylePalette);
+    Blt_Chain_Destroy(ops->stylePalette);
   }
-  if (elemPtr->activeIndices)
-    free(elemPtr->activeIndices);
+  if (lePtr->activeIndices)
+    free(lePtr->activeIndices);
 
-  if (elemPtr->fillPts)
-    free(elemPtr->fillPts);
+  if (lePtr->fillPts)
+    free(lePtr->fillPts);
 
-  if (elemPtr->fillGC)
-    Tk_FreeGC(graphPtr->display, elemPtr->fillGC);
+  if (lePtr->fillGC)
+    Tk_FreeGC(graphPtr->display, lePtr->fillGC);
 }
 
 // Configure
 
-static int ConfigureLineProc(Graph* graphPtr, Element *basePtr)
+static int ConfigureLineProc(Graph* graphPtr, Element *elemPtr)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
+  LineElement* lePtr = (LineElement*)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
-  if (ConfigureLinePenProc(graphPtr, (Pen *)&elemPtr->builtinPen) != TCL_OK)
+  if (ConfigureLinePenProc(graphPtr, (Pen *)&lePtr->builtinPen) != TCL_OK)
     return TCL_ERROR;
 
   // Point to the static normal/active pens if no external pens have been
   // selected.
-  Blt_ChainLink link = Blt_Chain_FirstLink(elemPtr->stylePalette);
+  Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette);
   if (!link) {
     link = Blt_Chain_AllocLink(sizeof(LineStyle));
-    Blt_Chain_LinkAfter(elemPtr->stylePalette, link, NULL);
+    Blt_Chain_LinkAfter(ops->stylePalette, link, NULL);
   } 
   LineStyle* stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
-  stylePtr->penPtr = NORMALPEN(elemPtr);
+  stylePtr->penPtr = NORMALPEN(ops);
 
   // Set the outline GC for this pen: GCForeground is outline color.
   // GCBackground is the fill color (only used for bitmap symbols).
   unsigned long gcMask =0;
   XGCValues gcValues;
-  if (elemPtr->fillFgColor) {
+  if (ops->fillFgColor) {
     gcMask |= GCForeground;
-    gcValues.foreground = elemPtr->fillFgColor->pixel;
+    gcValues.foreground = ops->fillFgColor->pixel;
   }
-  if (elemPtr->fillBgColor) {
+  if (lePtr->fillBgColor) {
     gcMask |= GCBackground;
-    gcValues.background = elemPtr->fillBgColor->pixel;
+    gcValues.background = lePtr->fillBgColor->pixel;
   }
   GC newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues);
-  if (elemPtr->fillGC)
-    Tk_FreeGC(graphPtr->display, elemPtr->fillGC);
-  elemPtr->fillGC = newGC;
+  if (lePtr->fillGC)
+    Tk_FreeGC(graphPtr->display, lePtr->fillGC);
+  lePtr->fillGC = newGC;
 
   return TCL_OK;
 }
@@ -379,22 +393,24 @@ static void ResetStylePalette(Blt_Chain styles)
   }
 }
 
-static int ScaleSymbol(LineElement* elemPtr, int normalSize)
+static int ScaleSymbol(LineElement* lePtr, int normalSize)
 {
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
   double scale = 1.0;
-  if (elemPtr->scaleSymbols) {
-    double xRange = (elemPtr->axes.x->max - elemPtr->axes.x->min);
-    double yRange = (elemPtr->axes.y->max - elemPtr->axes.y->min);
+  if (ops->scaleSymbols) {
+    double xRange = (ops->axes.x->max - ops->axes.x->min);
+    double yRange = (ops->axes.y->max - ops->axes.y->min);
     // Save the ranges as a baseline for future scaling
-    if (elemPtr->flags & SCALE_SYMBOL) {
-      elemPtr->xRange = xRange;
-      elemPtr->yRange = yRange;
-      elemPtr->flags &= ~SCALE_SYMBOL;
+    if (lePtr->flags & SCALE_SYMBOL) {
+      lePtr->xRange = xRange;
+      lePtr->yRange = yRange;
+      lePtr->flags &= ~SCALE_SYMBOL;
     }
     else {
       // Scale the symbol by the smallest change in the X or Y axes
-      double xScale = elemPtr->xRange / xRange;
-      double yScale = elemPtr->yRange / yRange;
+      double xScale = lePtr->xRange / xRange;
+      double yScale = lePtr->yRange / yRange;
       scale = MIN(xScale, yScale);
     }
   }
@@ -402,8 +418,8 @@ static int ScaleSymbol(LineElement* elemPtr, int normalSize)
 
   // 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(elemPtr->obj.graphPtr->hRange, 
-		     elemPtr->obj.graphPtr->vRange);
+  int maxSize = (int)MIN(lePtr->obj.graphPtr->hRange, 
+		     lePtr->obj.graphPtr->vRange);
   if (newSize > maxSize)
     newSize = maxSize;
 
@@ -413,19 +429,20 @@ static int ScaleSymbol(LineElement* elemPtr, int normalSize)
   return newSize;
 }
 
-static void GetScreenPoints(Graph* graphPtr, LineElement* elemPtr, 
+static void GetScreenPoints(Graph* graphPtr, LineElement* lePtr, 
 			    MapInfo *mapPtr)
 {
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
-  if (!elemPtr->coords.x || !elemPtr->coords.y) {
+  if (!ops->coords.x || !ops->coords.y) {
     mapPtr->screenPts = NULL;
     mapPtr->nScreenPts = 0;
     mapPtr->map = NULL;
   }
 
-  int np = NUMBEROFPOINTS(elemPtr);
-  double* x = elemPtr->coords.x->values;
-  double* y = elemPtr->coords.y->values;
+  int np = NUMBEROFPOINTS(ops);
+  double* x = ops->coords.x->values;
+  double* y = ops->coords.y->values;
   Point2d *points = (Point2d*)malloc(sizeof(Point2d) * np);
   int* map = (int*)malloc(sizeof(int) * np);
 
@@ -433,8 +450,8 @@ static void GetScreenPoints(Graph* graphPtr, LineElement* elemPtr,
   if (graphPtr->inverted) {
     for (int i = 0; i < np; i++) {
       if ((isfinite(x[i])) && (isfinite(y[i]))) {
-	points[count].x = Blt_HMap(elemPtr->axes.y, y[i]);
-	points[count].y = Blt_VMap(elemPtr->axes.x, x[i]);
+	points[count].x = Blt_HMap(ops->axes.y, y[i]);
+	points[count].y = Blt_VMap(ops->axes.x, x[i]);
 	map[count] = i;
 	count++;
       }
@@ -443,8 +460,8 @@ static void GetScreenPoints(Graph* graphPtr, LineElement* elemPtr,
   else {
     for (int i = 0; i < np; i++) {
       if ((isfinite(x[i])) && (isfinite(y[i]))) {
-	points[count].x = Blt_HMap(elemPtr->axes.x, x[i]);
-	points[count].y = Blt_VMap(elemPtr->axes.y, y[i]);
+	points[count].x = Blt_HMap(ops->axes.x, x[i]);
+	points[count].y = Blt_VMap(ops->axes.y, y[i]);
 	map[count] = i;
 	count++;
       }
@@ -504,7 +521,7 @@ static void GenerateSteps(MapInfo *mapPtr)
   mapPtr->nScreenPts = newSize;
 }
 
-static void GenerateSpline(Graph* graphPtr, LineElement* elemPtr, 
+static void GenerateSpline(Graph* graphPtr, LineElement* lePtr, 
 			   MapInfo *mapPtr)
 {
   Point2d *origPts, *iPts;
@@ -582,16 +599,16 @@ static void GenerateSpline(Graph* graphPtr, LineElement* elemPtr,
     }
   }
   niPts = count;
-  result = FALSE;
-  if (elemPtr->smooth == PEN_SMOOTH_NATURAL) {
+  result = 0;
+  if (lePtr->smooth == PEN_SMOOTH_NATURAL) {
     result = Blt_NaturalSpline(origPts, nOrigPts, iPts, niPts);
-  } else if (elemPtr->smooth == PEN_SMOOTH_QUADRATIC) {
+  } else if (lePtr->smooth == PEN_SMOOTH_QUADRATIC) {
     result = Blt_QuadraticSpline(origPts, nOrigPts, iPts, niPts);
   }
   if (!result) {
     /* The spline interpolation failed.  We'll fallback to the current
      * coordinates and do no smoothing (standard line segments).  */
-    elemPtr->smooth = PEN_SMOOTH_LINEAR;
+    lePtr->smooth = PEN_SMOOTH_LINEAR;
     free(iPts);
     free(map);
   } else {
@@ -603,7 +620,7 @@ static void GenerateSpline(Graph* graphPtr, LineElement* elemPtr,
   }
 }
 
-static void GenerateParametricSpline(Graph* graphPtr, LineElement* elemPtr, 
+static void GenerateParametricSpline(Graph* graphPtr, LineElement* lePtr, 
 				     MapInfo *mapPtr)
 {
   Region2d exts;
@@ -689,17 +706,17 @@ static void GenerateParametricSpline(Graph* graphPtr, LineElement* elemPtr,
   map[count] = mapPtr->map[i];
   count++;
   niPts = count;
-  result = FALSE;
-  if (elemPtr->smooth == PEN_SMOOTH_NATURAL) {
-    result = Blt_NaturalParametricSpline(origPts, nOrigPts, &exts, FALSE,
+  result = 0;
+  if (lePtr->smooth == PEN_SMOOTH_NATURAL) {
+    result = Blt_NaturalParametricSpline(origPts, nOrigPts, &exts, 0,
 					 iPts, niPts);
-  } else if (elemPtr->smooth == PEN_SMOOTH_CATROM) {
+  } else if (lePtr->smooth == PEN_SMOOTH_CATROM) {
     result = Blt_CatromParametricSpline(origPts, nOrigPts, iPts, niPts);
   }
   if (!result) {
     /* The spline interpolation failed.  We will fall back to the current
      * coordinates and do no smoothing (standard line segments).  */
-    elemPtr->smooth = PEN_SMOOTH_LINEAR;
+    lePtr->smooth = PEN_SMOOTH_LINEAR;
     free(iPts);
     free(map);
   } else {
@@ -711,7 +728,7 @@ static void GenerateParametricSpline(Graph* graphPtr, LineElement* elemPtr,
   }
 }
 
-static void MapSymbols(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
+static void MapSymbols(Graph* graphPtr, LineElement* lePtr, MapInfo *mapPtr)
 {
   Region2d exts;
   Point2d *pp;
@@ -731,38 +748,40 @@ static void MapSymbols(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
       count++;
     }
   }
-  elemPtr->symbolPts.points = points;
-  elemPtr->symbolPts.length = count;
-  elemPtr->symbolPts.map = map;
+  lePtr->symbolPts.points = points;
+  lePtr->symbolPts.length = count;
+  lePtr->symbolPts.map = map;
 }
 
-static void MapActiveSymbols(Graph* graphPtr, LineElement* elemPtr)
+static void MapActiveSymbols(Graph* graphPtr, LineElement* lePtr)
 {
-  if (elemPtr->activePts.points) {
-    free(elemPtr->activePts.points);
-    elemPtr->activePts.points = NULL;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
+  if (lePtr->activePts.points) {
+    free(lePtr->activePts.points);
+    lePtr->activePts.points = NULL;
   }
-  if (elemPtr->activePts.map) {
-    free(elemPtr->activePts.map);
-    elemPtr->activePts.map = NULL;
+  if (lePtr->activePts.map) {
+    free(lePtr->activePts.map);
+    lePtr->activePts.map = NULL;
   }
 
   Region2d exts;
   Blt_GraphExtents(graphPtr, &exts);
 
-  Point2d *points = (Point2d*)malloc(sizeof(Point2d) * elemPtr->nActiveIndices);
-  int* map = (int*)malloc(sizeof(int) * elemPtr->nActiveIndices);
-  int np = NUMBEROFPOINTS(elemPtr);
+  Point2d *points = (Point2d*)malloc(sizeof(Point2d) * lePtr->nActiveIndices);
+  int* map = (int*)malloc(sizeof(int) * lePtr->nActiveIndices);
+  int np = NUMBEROFPOINTS(ops);
   int count = 0;
-  if (elemPtr->coords.x && elemPtr->coords.y) {
-    for (int ii=0; ii<elemPtr->nActiveIndices; ii++) {
-      int iPoint = elemPtr->activeIndices[ii];
+  if (ops->coords.x && ops->coords.y) {
+    for (int ii=0; ii<lePtr->nActiveIndices; ii++) {
+      int iPoint = lePtr->activeIndices[ii];
       if (iPoint >= np)
 	continue;
 
-      double x = elemPtr->coords.x->values[iPoint];
-      double y = elemPtr->coords.y->values[iPoint];
-      points[count] = Blt_Map2D(graphPtr, x, y, &elemPtr->axes);
+      double x = ops->coords.x->values[iPoint];
+      double y = ops->coords.y->values[iPoint];
+      points[count] = Blt_Map2D(graphPtr, x, y, &ops->axes);
       map[count] = iPoint;
       if (PointInRegion(&exts, points[count].x, points[count].y)) {
 	count++;
@@ -771,151 +790,152 @@ static void MapActiveSymbols(Graph* graphPtr, LineElement* elemPtr)
   }
 
   if (count > 0) {
-    elemPtr->activePts.points = points;
-    elemPtr->activePts.map = map;
+    lePtr->activePts.points = points;
+    lePtr->activePts.map = map;
   }
   else {
     free(points);
     free(map);	
   }
-  elemPtr->activePts.length = count;
-  elemPtr->flags &= ~ACTIVE_PENDING;
+  lePtr->activePts.length = count;
+  lePtr->flags &= ~ACTIVE_PENDING;
 }
 
-static void MergePens(LineElement* elemPtr, LineStyle **styleMap)
+static void MergePens(LineElement* lePtr, LineStyle **styleMap)
 {
-  if (Blt_Chain_GetLength(elemPtr->stylePalette) < 2) {
-    Blt_ChainLink link = Blt_Chain_FirstLink(elemPtr->stylePalette);
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
+  if (Blt_Chain_GetLength(ops->stylePalette) < 2) {
+    Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette);
     LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
-    stylePtr->errorBarCapWidth = elemPtr->errorBarCapWidth;
-    stylePtr->lines.length = elemPtr->lines.length;
-    stylePtr->lines.segments = elemPtr->lines.segments;
-    stylePtr->symbolPts.length = elemPtr->symbolPts.length;
-    stylePtr->symbolPts.points = elemPtr->symbolPts.points;
-    stylePtr->xeb.length = elemPtr->xeb.length;
-    stylePtr->xeb.segments = elemPtr->xeb.segments;
-    stylePtr->yeb.length = elemPtr->yeb.length;
-    stylePtr->yeb.segments = elemPtr->yeb.segments;
+    stylePtr->lines.length = lePtr->lines.length;
+    stylePtr->lines.segments = lePtr->lines.segments;
+    stylePtr->symbolPts.length = lePtr->symbolPts.length;
+    stylePtr->symbolPts.points = lePtr->symbolPts.points;
+    stylePtr->xeb.length = lePtr->xeb.length;
+    stylePtr->xeb.segments = lePtr->xeb.segments;
+    stylePtr->yeb.length = lePtr->yeb.length;
+    stylePtr->yeb.segments = lePtr->yeb.segments;
     return;
   }
 
   /* We have more than one style. Group line segments and points of like pen
    * styles.  */
-  if (elemPtr->lines.length > 0) {
+  if (lePtr->lines.length > 0) {
     Blt_ChainLink link;
     Segment2d *sp;
     int *ip;
 
     Segment2d* segments = 
-      (Segment2d*)malloc(elemPtr->lines.length * sizeof(Segment2d));
-    int* map = (int*)malloc(elemPtr->lines.length * sizeof(int));
+      (Segment2d*)malloc(lePtr->lines.length * sizeof(Segment2d));
+    int* map = (int*)malloc(lePtr->lines.length * sizeof(int));
     sp = segments, ip = map;
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
+    for (link = Blt_Chain_FirstLink(ops->stylePalette); 
 	 link; link = Blt_Chain_NextLink(link)) {
       LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
       stylePtr->lines.segments = sp;
-      for (int i = 0; i < elemPtr->lines.length; i++) {
+      for (int i = 0; i < lePtr->lines.length; i++) {
 	int iData;
 
-	iData = elemPtr->lines.map[i];
+	iData = lePtr->lines.map[i];
 	if (styleMap[iData] == stylePtr) {
-	  *sp++ = elemPtr->lines.segments[i];
+	  *sp++ = lePtr->lines.segments[i];
 	  *ip++ = iData;
 	}
       }
       stylePtr->lines.length = sp - stylePtr->lines.segments;
     }
-    free(elemPtr->lines.segments);
-    elemPtr->lines.segments = segments;
-    free(elemPtr->lines.map);
-    elemPtr->lines.map = map;
+    free(lePtr->lines.segments);
+    lePtr->lines.segments = segments;
+    free(lePtr->lines.map);
+    lePtr->lines.map = map;
   }
-  if (elemPtr->symbolPts.length > 0) {
+  if (lePtr->symbolPts.length > 0) {
     Blt_ChainLink link;
     int *ip;
     Point2d *pp;
 
     Point2d* points = 
-      (Point2d*)malloc(elemPtr->symbolPts.length * sizeof(Point2d));
-    int* map = (int*)malloc(elemPtr->symbolPts.length * sizeof(int));
+      (Point2d*)malloc(lePtr->symbolPts.length * sizeof(Point2d));
+    int* map = (int*)malloc(lePtr->symbolPts.length * sizeof(int));
     pp = points, ip = map;
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
+    for (link = Blt_Chain_FirstLink(ops->stylePalette); 
 	 link; link = Blt_Chain_NextLink(link)) {
       LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
       stylePtr->symbolPts.points = pp;
-      for (int i = 0; i < elemPtr->symbolPts.length; i++) {
+      for (int i = 0; i < lePtr->symbolPts.length; i++) {
 	int iData;
 
-	iData = elemPtr->symbolPts.map[i];
+	iData = lePtr->symbolPts.map[i];
 	if (styleMap[iData] == stylePtr) {
-	  *pp++ = elemPtr->symbolPts.points[i];
+	  *pp++ = lePtr->symbolPts.points[i];
 	  *ip++ = iData;
 	}
       }
       stylePtr->symbolPts.length = pp - stylePtr->symbolPts.points;
     }
-    free(elemPtr->symbolPts.points);
-    free(elemPtr->symbolPts.map);
-    elemPtr->symbolPts.points = points;
-    elemPtr->symbolPts.map = map;
+    free(lePtr->symbolPts.points);
+    free(lePtr->symbolPts.map);
+    lePtr->symbolPts.points = points;
+    lePtr->symbolPts.map = map;
   }
-  if (elemPtr->xeb.length > 0) {
+  if (lePtr->xeb.length > 0) {
     Segment2d *sp;
     int *ip;
     Blt_ChainLink link;
 
     Segment2d *segments = 
-      (Segment2d*)malloc(elemPtr->xeb.length * sizeof(Segment2d));
-    int* map = (int*)malloc(elemPtr->xeb.length * sizeof(int));
+      (Segment2d*)malloc(lePtr->xeb.length * sizeof(Segment2d));
+    int* map = (int*)malloc(lePtr->xeb.length * sizeof(int));
     sp = segments, ip = map;
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
+    for (link = Blt_Chain_FirstLink(ops->stylePalette); 
 	 link; link = Blt_Chain_NextLink(link)) {
       LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
       stylePtr->xeb.segments = sp;
-      for (int i = 0; i < elemPtr->xeb.length; i++) {
+      for (int i = 0; i < lePtr->xeb.length; i++) {
 	int iData;
 
-	iData = elemPtr->xeb.map[i];
+	iData = lePtr->xeb.map[i];
 	if (styleMap[iData] == stylePtr) {
-	  *sp++ = elemPtr->xeb.segments[i];
+	  *sp++ = lePtr->xeb.segments[i];
 	  *ip++ = iData;
 	}
       }
       stylePtr->xeb.length = sp - stylePtr->xeb.segments;
     }
-    free(elemPtr->xeb.segments);
-    free(elemPtr->xeb.map);
-    elemPtr->xeb.segments = segments;
-    elemPtr->xeb.map = map;
+    free(lePtr->xeb.segments);
+    free(lePtr->xeb.map);
+    lePtr->xeb.segments = segments;
+    lePtr->xeb.map = map;
   }
-  if (elemPtr->yeb.length > 0) {
+  if (lePtr->yeb.length > 0) {
     Segment2d *sp;
     int *ip;
     Blt_ChainLink link;
 
     Segment2d *segments = 
-      (Segment2d*)malloc(elemPtr->yeb.length * sizeof(Segment2d));
-    int* map = (int*)malloc(elemPtr->yeb.length * sizeof(int));
+      (Segment2d*)malloc(lePtr->yeb.length * sizeof(Segment2d));
+    int* map = (int*)malloc(lePtr->yeb.length * sizeof(int));
     sp = segments, ip = map;
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
+    for (link = Blt_Chain_FirstLink(ops->stylePalette); 
 	 link; link = Blt_Chain_NextLink(link)) {
       LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
       stylePtr->yeb.segments = sp;
-      for (int i = 0; i < elemPtr->yeb.length; i++) {
+      for (int i = 0; i < lePtr->yeb.length; i++) {
 	int iData;
 
-	iData = elemPtr->yeb.map[i];
+	iData = lePtr->yeb.map[i];
 	if (styleMap[iData] == stylePtr) {
-	  *sp++ = elemPtr->yeb.segments[i];
+	  *sp++ = lePtr->yeb.segments[i];
 	  *ip++ = iData;
 	}
       }
       stylePtr->yeb.length = sp - stylePtr->yeb.segments;
     }
-    free(elemPtr->yeb.segments);
-    elemPtr->yeb.segments = segments;
-    free(elemPtr->yeb.map);
-    elemPtr->yeb.map = map;
+    free(lePtr->yeb.segments);
+    lePtr->yeb.segments = segments;
+    free(lePtr->yeb.map);
+    lePtr->yeb.map = map;
   }
 }
 
@@ -988,7 +1008,7 @@ static int ClipSegment(Region2d *extsPtr, int code1, int code2,
   return (!inside);
 }
 
-static void SaveTrace(LineElement* elemPtr, int start, int length,
+static void SaveTrace(LineElement* lePtr, int start, int length,
 		      MapInfo *mapPtr)
 {
   int i, j;
@@ -1016,53 +1036,51 @@ static void SaveTrace(LineElement* elemPtr, int start, int length,
   tracePtr->screenPts.points = screenPts;
   tracePtr->screenPts.map = map;
   tracePtr->start = start;
-  if (elemPtr->traces == NULL) {
-    elemPtr->traces = Blt_Chain_Create();
+  if (lePtr->traces == NULL) {
+    lePtr->traces = Blt_Chain_Create();
   }
-  Blt_Chain_Append(elemPtr->traces, tracePtr);
+  Blt_Chain_Append(lePtr->traces, tracePtr);
 }
 
-static void FreeTraces(LineElement* elemPtr)
+static void FreeTraces(LineElement* lePtr)
 {
   Blt_ChainLink link;
 
-  for (link = Blt_Chain_FirstLink(elemPtr->traces); link;
+  for (link = Blt_Chain_FirstLink(lePtr->traces); link;
        link = Blt_Chain_NextLink(link)) {
     bltTrace *tracePtr = (bltTrace*)Blt_Chain_GetValue(link);
     free(tracePtr->screenPts.map);
     free(tracePtr->screenPts.points);
     free(tracePtr);
   }
-  Blt_Chain_Destroy(elemPtr->traces);
-  elemPtr->traces = NULL;
+  Blt_Chain_Destroy(lePtr->traces);
+  lePtr->traces = NULL;
 }
 
-static void MapTraces(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
+static void MapTraces(Graph* graphPtr, LineElement* lePtr, MapInfo *mapPtr)
 {
-  Point2d *p, *q;
-  Region2d exts;
-  int code1;
-  int i;
-  int start, count;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
+  Region2d exts;
   Blt_GraphExtents(graphPtr, &exts);
-  count = 1;
-  code1 = OutCode(&exts, mapPtr->screenPts);
-  p = mapPtr->screenPts;
-  q = p + 1;
-  for (i = 1; i < mapPtr->nScreenPts; i++, p++, q++) {
-    Point2d s;
-    int code2;
-    int broken, offscreen;
+  int count = 1;
+  int code1 = OutCode(&exts, mapPtr->screenPts);
+  Point2d* p = mapPtr->screenPts;
+  Point2d* q = p + 1;
 
-    s.x = s.y = 0;
-    code2 = OutCode(&exts, q);
+  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);
     if (code2 != 0) {
       /* Save the coordinates of the last point, before clipping */
       s = *q;
     }
-    broken = BROKEN_TRACE(elemPtr->penDir, p->x, q->x);
-    offscreen = ClipSegment(&exts, code1, code2, p, q);
+    int broken = BROKEN_TRACE(ops->penDir, p->x, q->x);
+    int offscreen = ClipSegment(&exts, code1, code2, p, q);
     if (broken || offscreen) {
 
       /*
@@ -1073,11 +1091,12 @@ static void MapTraces(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
        */
 
       if (count > 1) {
-	start = i - count;
-	SaveTrace(elemPtr, start, count, mapPtr);
+	start = ii - count;
+	SaveTrace(lePtr, start, count, mapPtr);
 	count = 1;
       }
-    } else {
+    }
+    else {
       count++;		/* Add the point to the trace. */
       if (code2 != 0) {
 
@@ -1087,34 +1106,34 @@ static void MapTraces(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
 	 * (before clipping) after saving the trace.
 	 */
 
-	start = i - (count - 1);
-	SaveTrace(elemPtr, start, count, mapPtr);
-	mapPtr->screenPts[i] = s;
+	start = ii - (count - 1);
+	SaveTrace(lePtr, start, count, mapPtr);
+	mapPtr->screenPts[ii] = s;
 	count = 1;
       }
     }
     code1 = code2;
   }
   if (count > 1) {
-    start = i - count;
-    SaveTrace(elemPtr, start, count, mapPtr);
+    start = ii - count;
+    SaveTrace(lePtr, start, count, mapPtr);
   }
 }
 
-static void MapFillArea(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
+static void MapFillArea(Graph* graphPtr, LineElement* lePtr, MapInfo *mapPtr)
 {
-  Region2d exts;
-  int np;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
-  if (elemPtr->fillPts) {
-    free(elemPtr->fillPts);
-    elemPtr->fillPts = NULL;
-    elemPtr->nFillPts = 0;
+  if (lePtr->fillPts) {
+    free(lePtr->fillPts);
+    lePtr->fillPts = NULL;
+    lePtr->nFillPts = 0;
   }
-  if (mapPtr->nScreenPts < 3) {
+  if (mapPtr->nScreenPts < 3)
     return;
-  }
-  np = mapPtr->nScreenPts + 3;
+
+  int np = mapPtr->nScreenPts + 3;
+  Region2d exts;
   Blt_GraphExtents(graphPtr, &exts);
 
   Point2d* origPts = (Point2d*)malloc(sizeof(Point2d) * np);
@@ -1122,7 +1141,7 @@ static void MapFillArea(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
     double minX;
     int i;
 
-    minX = (double)elemPtr->axes.y->screenMin;
+    minX = (double)ops->axes.y->screenMin;
     for (i = 0; i < mapPtr->nScreenPts; i++) {
       origPts[i].x = mapPtr->screenPts[i].x + 1;
       origPts[i].y = mapPtr->screenPts[i].y;
@@ -1143,7 +1162,7 @@ static void MapFillArea(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
     double maxY;
     int i;
 
-    maxY = (double)elemPtr->axes.y->bottom;
+    maxY = (double)ops->axes.y->bottom;
     for (i = 0; i < mapPtr->nScreenPts; i++) {
       origPts[i].x = mapPtr->screenPts[i].x + 1;
       origPts[i].y = mapPtr->screenPts[i].y;
@@ -1169,67 +1188,80 @@ static void MapFillArea(Graph* graphPtr, LineElement* elemPtr, MapInfo *mapPtr)
   if (np < 3) {
     free(clipPts);
   } else {
-    elemPtr->fillPts = clipPts;
-    elemPtr->nFillPts = np;
+    lePtr->fillPts = clipPts;
+    lePtr->nFillPts = np;
   }
 }
 
-static void ResetLine(LineElement* elemPtr)
+static void ResetLine(LineElement* lePtr)
 {
-  FreeTraces(elemPtr);
-  ResetStylePalette(elemPtr->stylePalette);
-  if (elemPtr->symbolPts.points) {
-    free(elemPtr->symbolPts.points);
-  }
-  if (elemPtr->symbolPts.map) {
-    free(elemPtr->symbolPts.map);
-  }
-  if (elemPtr->lines.segments) {
-    free(elemPtr->lines.segments);
-  }
-  if (elemPtr->lines.map) {
-    free(elemPtr->lines.map);
-  }
-  if (elemPtr->activePts.points) {
-    free(elemPtr->activePts.points);
-  }
-  if (elemPtr->activePts.map) {
-    free(elemPtr->activePts.map);
-  }
-  if (elemPtr->xeb.segments) {
-    free(elemPtr->xeb.segments);
-  }
-  if (elemPtr->xeb.map) {
-    free(elemPtr->xeb.map);
-  }
-  if (elemPtr->yeb.segments) {
-    free(elemPtr->yeb.segments);
-  }
-  if (elemPtr->yeb.map) {
-    free(elemPtr->yeb.map);
-  }
-  elemPtr->xeb.segments = elemPtr->yeb.segments = elemPtr->lines.segments = NULL;
-  elemPtr->symbolPts.points = elemPtr->activePts.points = NULL;
-  elemPtr->lines.map = elemPtr->symbolPts.map = elemPtr->xeb.map = 
-    elemPtr->yeb.map = elemPtr->activePts.map = NULL;
-  elemPtr->activePts.length = elemPtr->symbolPts.length = 
-    elemPtr->lines.length = elemPtr->xeb.length = elemPtr->yeb.length = 0;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
+  FreeTraces(lePtr);
+  ResetStylePalette(ops->stylePalette);
+  if (lePtr->symbolPts.points) {
+    free(lePtr->symbolPts.points);
+    lePtr->symbolPts.points = NULL;
+  }
+
+  if (lePtr->symbolPts.map)
+    free(lePtr->symbolPts.map);
+  lePtr->symbolPts.map = NULL;
+  lePtr->symbolPts.length = 0;
+
+  if (lePtr->lines.segments)
+    free(lePtr->lines.segments);
+  lePtr->lines.segments = NULL;
+  lePtr->lines.length = 0;
+
+  if (lePtr->lines.map)
+    free(lePtr->lines.map);
+  lePtr->lines.map = NULL;
+
+  if (lePtr->activePts.points)
+    free(lePtr->activePts.points);
+  lePtr->activePts.points = NULL;
+  lePtr->activePts.length = 0;
+
+  if (lePtr->activePts.map)
+    free(lePtr->activePts.map);
+  lePtr->activePts.map = NULL;
+
+  if (lePtr->xeb.segments)
+    free(lePtr->xeb.segments);
+  lePtr->xeb.segments = NULL;
+
+  if (lePtr->xeb.map)
+    free(lePtr->xeb.map);
+  lePtr->xeb.map = NULL;
+  lePtr->xeb.length = 0;
+
+  if (lePtr->yeb.segments)
+    free(lePtr->yeb.segments);
+  lePtr->yeb.segments = NULL;
+  lePtr->yeb.length = 0;
+
+  if (lePtr->yeb.map)
+    free(lePtr->yeb.map);
+  lePtr->yeb.map = NULL;
 }
 
-static void MapErrorBars(Graph* graphPtr, LineElement* elemPtr, 
+static void MapErrorBars(Graph* graphPtr, LineElement* lePtr, 
 			 LineStyle **styleMap)
 {
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
   Region2d exts;
   Blt_GraphExtents(graphPtr, &exts);
 
   int n =0;
-  int np = NUMBEROFPOINTS(elemPtr);
-  if (elemPtr->coords.x && elemPtr->coords.y) {
-    if (elemPtr->xError && (elemPtr->xError->nValues > 0))
-      n = MIN(elemPtr->xError->nValues, np);
+  int np = NUMBEROFPOINTS(ops);
+  if (ops->coords.x && ops->coords.y) {
+    if (ops->xError && (ops->xError->nValues > 0))
+      n = MIN(ops->xError->nValues, np);
     else
-      if (elemPtr->xHigh && elemPtr->xLow)
-	n = MIN3(elemPtr->xHigh->nValues, elemPtr->xLow->nValues, np);
+      if (ops->xHigh && ops->xLow)
+	n = MIN3(ops->xHigh->nValues, ops->xLow->nValues, np);
   }
 
   if (n > 0) {
@@ -1246,22 +1278,22 @@ static void MapErrorBars(Graph* graphPtr, LineElement* elemPtr,
       double high, low;
       LineStyle *stylePtr;
 
-      x = elemPtr->coords.x->values[i];
-      y = elemPtr->coords.y->values[i];
+      x = ops->coords.x->values[i];
+      y = ops->coords.y->values[i];
       stylePtr = styleMap[i];
       if ((isfinite(x)) && (isfinite(y))) {
-	if (elemPtr->xError->nValues > 0) {
-	  high = x + elemPtr->xError->values[i];
-	  low = x - elemPtr->xError->values[i];
+	if (ops->xError->nValues > 0) {
+	  high = x + ops->xError->values[i];
+	  low = x - ops->xError->values[i];
 	} else {
-	  high = elemPtr->xHigh ? elemPtr->xHigh->values[i] : 0;
-	  low  = elemPtr->xLow ? elemPtr->xLow->values[i] : 0;
+	  high = ops->xHigh ? ops->xHigh->values[i] : 0;
+	  low  = ops->xLow ? ops->xLow->values[i] : 0;
 	}
 	if ((isfinite(high)) && (isfinite(low)))  {
 	  Point2d p, q;
 
-	  p = Blt_Map2D(graphPtr, high, y, &elemPtr->axes);
-	  q = Blt_Map2D(graphPtr, low, y, &elemPtr->axes);
+	  p = Blt_Map2D(graphPtr, high, y, &ops->axes);
+	  q = Blt_Map2D(graphPtr, low, y, &ops->axes);
 	  segPtr->p = p;
 	  segPtr->q = q;
 	  if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) {
@@ -1287,18 +1319,18 @@ static void MapErrorBars(Graph* graphPtr, LineElement* elemPtr,
 	}
       }
     }
-    elemPtr->xeb.segments = errorBars;
-    elemPtr->xeb.length = segPtr - errorBars;
-    elemPtr->xeb.map = errorToData;
+    lePtr->xeb.segments = errorBars;
+    lePtr->xeb.length = segPtr - errorBars;
+    lePtr->xeb.map = errorToData;
   }
 
   n =0;
-  if (elemPtr->coords.x && elemPtr->coords.y) {
-    if (elemPtr->yError && (elemPtr->yError->nValues > 0))
-      n = MIN(elemPtr->yError->nValues, np);
+  if (ops->coords.x && ops->coords.y) {
+    if (ops->yError && (ops->yError->nValues > 0))
+      n = MIN(ops->yError->nValues, np);
     else
-      if (elemPtr->yHigh && elemPtr->yLow)
-	n = MIN3(elemPtr->yHigh->nValues, elemPtr->yLow->nValues, np);
+      if (ops->yHigh && ops->yLow)
+	n = MIN3(ops->yHigh->nValues, ops->yLow->nValues, np);
   }
 
   if (n > 0) {
@@ -1315,22 +1347,22 @@ static void MapErrorBars(Graph* graphPtr, LineElement* elemPtr,
       double high, low;
       LineStyle *stylePtr;
 
-      x = elemPtr->coords.x->values[i];
-      y = elemPtr->coords.y->values[i];
+      x = ops->coords.x->values[i];
+      y = ops->coords.y->values[i];
       stylePtr = styleMap[i];
       if ((isfinite(x)) && (isfinite(y))) {
-	if (elemPtr->yError->nValues > 0) {
-	  high = y + elemPtr->yError->values[i];
-	  low = y - elemPtr->yError->values[i];
+	if (ops->yError->nValues > 0) {
+	  high = y + ops->yError->values[i];
+	  low = y - ops->yError->values[i];
 	} else {
-	  high = elemPtr->yHigh->values[i];
-	  low = elemPtr->yLow->values[i];
+	  high = ops->yHigh->values[i];
+	  low = ops->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);
+	  p = Blt_Map2D(graphPtr, x, high, &ops->axes);
+	  q = Blt_Map2D(graphPtr, x, low, &ops->axes);
 	  segPtr->p = p;
 	  segPtr->q = q;
 	  if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) {
@@ -1356,35 +1388,36 @@ static void MapErrorBars(Graph* graphPtr, LineElement* elemPtr,
 	}
       }
     }
-    elemPtr->yeb.segments = errorBars;
-    elemPtr->yeb.length = segPtr - errorBars;
-    elemPtr->yeb.map = errorToData;
+    lePtr->yeb.segments = errorBars;
+    lePtr->yeb.length = segPtr - errorBars;
+    lePtr->yeb.map = errorToData;
   }
 }
 
-static void MapLineProc(Graph* graphPtr, Element *basePtr)
+static void MapLineProc(Graph* graphPtr, Element *elemPtr)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
     
-  ResetLine(elemPtr);
-  if (!elemPtr->coords.x || !elemPtr->coords.y ||
-      !elemPtr->coords.x->nValues || !elemPtr->coords.y->nValues)
+  ResetLine(lePtr);
+  if (!ops->coords.x || !ops->coords.y ||
+      !ops->coords.x->nValues || !ops->coords.y->nValues)
     return;
-  int np = NUMBEROFPOINTS(elemPtr);
+  int np = NUMBEROFPOINTS(ops);
 
   MapInfo mi;
-  GetScreenPoints(graphPtr, elemPtr, &mi);
-  MapSymbols(graphPtr, elemPtr, &mi);
+  GetScreenPoints(graphPtr, lePtr, &mi);
+  MapSymbols(graphPtr, lePtr, &mi);
 
-  if ((elemPtr->flags & ACTIVE_PENDING) && (elemPtr->nActiveIndices > 0))
-    MapActiveSymbols(graphPtr, elemPtr);
+  if ((lePtr->flags & ACTIVE_PENDING) && (lePtr->nActiveIndices > 0))
+    MapActiveSymbols(graphPtr, lePtr);
 
   // Map connecting line segments if they are to be displayed.
-  elemPtr->smooth = elemPtr->reqSmooth;
-  if ((np > 1) && (elemPtr->builtinPen.traceWidth > 0)) {
+  lePtr->smooth = 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 (elemPtr->smooth) {
+    switch (lePtr->smooth) {
     case PEN_SMOOTH_STEP:
       GenerateSteps(&mi);
       break;
@@ -1393,56 +1426,57 @@ static void MapLineProc(Graph* graphPtr, Element *basePtr)
     case PEN_SMOOTH_QUADRATIC:
       // Can't interpolate with less than three points
       if (mi.nScreenPts < 3)
-	elemPtr->smooth = PEN_SMOOTH_LINEAR;
+	lePtr->smooth = PEN_SMOOTH_LINEAR;
       else
-	GenerateSpline(graphPtr, elemPtr, &mi);
+	GenerateSpline(graphPtr, lePtr, &mi);
       break;
 
     case PEN_SMOOTH_CATROM:
       // Can't interpolate with less than three points
       if (mi.nScreenPts < 3)
-	elemPtr->smooth = PEN_SMOOTH_LINEAR;
+	lePtr->smooth = PEN_SMOOTH_LINEAR;
       else
-	GenerateParametricSpline(graphPtr, elemPtr, &mi);
+	GenerateParametricSpline(graphPtr, lePtr, &mi);
       break;
 
     default:
       break;
     }
-    if (elemPtr->rTolerance > 0.0) {
-      ReducePoints(&mi, elemPtr->rTolerance);
+    if (ops->rTolerance > 0.0) {
+      ReducePoints(&mi, ops->rTolerance);
     }
-    if (elemPtr->fillBg) {
-      MapFillArea(graphPtr, elemPtr, &mi);
+    if (ops->fillBg) {
+      MapFillArea(graphPtr, lePtr, &mi);
     }
-    MapTraces(graphPtr, elemPtr, &mi);
+    MapTraces(graphPtr, lePtr, &mi);
   }
   free(mi.screenPts);
   free(mi.map);
 
   // Set the symbol size of all the pen styles
-  for (Blt_ChainLink link = Blt_Chain_FirstLink(elemPtr->stylePalette); link;
+  for (Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette); link;
        link = Blt_Chain_NextLink(link)) {
     LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
     LinePen* penPtr = (LinePen *)stylePtr->penPtr;
-    int size = ScaleSymbol(elemPtr, penPtr->symbol.size);
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+    int size = ScaleSymbol(lePtr, penOps->symbol.size);
     stylePtr->symbolSize = size;
-    stylePtr->errorBarCapWidth = (penPtr->errorBarCapWidth > 0) 
-      ? penPtr->errorBarCapWidth : Round(size * 0.6666666);
+    stylePtr->errorBarCapWidth = (penOps->errorBarCapWidth > 0) 
+      ? penOps->errorBarCapWidth : Round(size * 0.6666666);
     stylePtr->errorBarCapWidth /= 2;
   }
 
-  LineStyle **styleMap = (LineStyle **)Blt_StyleMap((Element *)elemPtr);
-  if (((elemPtr->yHigh && elemPtr->yHigh->nValues > 0) &&
-       (elemPtr->yLow && elemPtr->yLow->nValues > 0)) ||
-      ((elemPtr->xHigh && elemPtr->xHigh->nValues > 0) &&
-       (elemPtr->xLow && elemPtr->xLow->nValues > 0)) ||
-      (elemPtr->xError && elemPtr->xError->nValues > 0) ||
-      (elemPtr->yError && elemPtr->yError->nValues > 0)) {
-    MapErrorBars(graphPtr, elemPtr, styleMap);
+  LineStyle **styleMap = (LineStyle **)Blt_StyleMap((Element *)lePtr);
+  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(graphPtr, lePtr, styleMap);
   }
 
-  MergePens(elemPtr, styleMap);
+  MergePens(lePtr, styleMap);
   free(styleMap);
 }
 
@@ -1563,9 +1597,10 @@ static double DistanceToYProc(int x, int y, Point2d *p, Point2d *q, Point2d *t)
   return fabs(d);
 }
 
-static int ClosestTrace(Graph* graphPtr, LineElement* elemPtr,
+static int ClosestTrace(Graph* graphPtr, LineElement* lePtr,
 			DistanceProc *distProc)
 {
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
   ClosestSearch* searchPtr = &graphPtr->search;
 
   Blt_ChainLink link;
@@ -1576,7 +1611,7 @@ static int ClosestTrace(Graph* graphPtr, LineElement* elemPtr,
   iClose = -1;			/* Suppress compiler warning. */
   dMin = searchPtr->dist;
   closest.x = closest.y = 0;		/* Suppress compiler warning. */
-  for (link = Blt_Chain_FirstLink(elemPtr->traces); link;
+  for (link = Blt_Chain_FirstLink(lePtr->traces); link;
        link = Blt_Chain_NextLink(link)) {
     Point2d *p, *pend;
 
@@ -1596,100 +1631,94 @@ static int ClosestTrace(Graph* graphPtr, LineElement* elemPtr,
   }
   if (dMin < searchPtr->dist) {
     searchPtr->dist = dMin;
-    searchPtr->elemPtr = (Element *)elemPtr;
+    searchPtr->elemPtr = (Element*)lePtr;
     searchPtr->index = iClose;
-    searchPtr->point = Blt_InvMap2D(graphPtr, closest.x, closest.y,
-				    &elemPtr->axes);
-    return TRUE;
+    searchPtr->point = Blt_InvMap2D(graphPtr, closest.x, closest.y, &ops->axes);
+    return 1;
   }
-  return FALSE;
+  return 0;
 }
 
-static void ClosestPoint(LineElement* elemPtr, ClosestSearch *searchPtr)
+static void ClosestPoint(LineElement* lePtr, ClosestSearch *searchPtr)
 {
-  double dMin;
-  int count, iClose;
-  Point2d *pp;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
-  dMin = searchPtr->dist;
-  iClose = 0;
+  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.
-   */
-  for (pp = elemPtr->symbolPts.points, count = 0; 
-       count < elemPtr->symbolPts.length; count++, pp++) {
-    double dx, dy;
+  // 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;
+  Point2d *pp;
+  for (pp = lePtr->symbolPts.points, count = 0; 
+       count < lePtr->symbolPts.length; count++, pp++) {
+    double dx = (double)(searchPtr->x - pp->x);
+    double dy = (double)(searchPtr->y - pp->y);
     double d;
-
-    dx = (double)(searchPtr->x - pp->x);
-    dy = (double)(searchPtr->y - pp->y);
-    if (searchPtr->along == SEARCH_BOTH) {
+    if (searchPtr->along == SEARCH_BOTH)
       d = hypot(dx, dy);
-    } else if (searchPtr->along == SEARCH_X) {
+    else if (searchPtr->along == SEARCH_X)
       d = dx;
-    } else if (searchPtr->along == SEARCH_Y) {
+    else if (searchPtr->along == SEARCH_Y)
       d = dy;
-    } else {
-      /* This can't happen */
+    else
       continue;
-    }
+
     if (d < dMin) {
-      iClose = elemPtr->symbolPts.map[count];
+      iClose = lePtr->symbolPts.map[count];
       dMin = d;
     }
   }
   if (dMin < searchPtr->dist) {
-    searchPtr->elemPtr = (Element *)elemPtr;
+    searchPtr->elemPtr = (Element*)lePtr;
     searchPtr->dist = dMin;
     searchPtr->index = iClose;
-    searchPtr->point.x = elemPtr->coords.x->values[iClose];
-    searchPtr->point.y = elemPtr->coords.y->values[iClose];
+    searchPtr->point.x = ops->coords.x->values[iClose];
+    searchPtr->point.y = ops->coords.y->values[iClose];
   }
 }
 
-static void GetLineExtentsProc(Element *basePtr, Region2d *extsPtr)
+static void GetLineExtentsProc(Element *elemPtr, Region2d *extsPtr)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
-  int np;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
   extsPtr->top = extsPtr->left = DBL_MAX;
   extsPtr->bottom = extsPtr->right = -DBL_MAX;
 
-  if (!elemPtr->coords.x || !elemPtr->coords.y ||
-      !elemPtr->coords.x->nValues || !elemPtr->coords.y->nValues)
+  if (!ops->coords.x || !ops->coords.y ||
+      !ops->coords.x->nValues || !ops->coords.y->nValues)
     return;
-  np = NUMBEROFPOINTS(elemPtr);
+  int np = NUMBEROFPOINTS(ops);
 
-  extsPtr->right = elemPtr->coords.x->max;
-  if ((elemPtr->coords.x->min <= 0.0) && (elemPtr->axes.x->logScale))
-    extsPtr->left = Blt_FindElemValuesMinimum(elemPtr->coords.x, DBL_MIN);
+  extsPtr->right = ops->coords.x->max;
+  if ((ops->coords.x->min <= 0.0) && (ops->axes.x->logScale))
+    extsPtr->left = Blt_FindElemValuesMinimum(ops->coords.x, DBL_MIN);
   else
-    extsPtr->left = elemPtr->coords.x->min;
+    extsPtr->left = ops->coords.x->min;
 
-  extsPtr->bottom = elemPtr->coords.y->max;
-  if ((elemPtr->coords.y->min <= 0.0) && (elemPtr->axes.y->logScale))
-    extsPtr->top = Blt_FindElemValuesMinimum(elemPtr->coords.y, DBL_MIN);
+  extsPtr->bottom = ops->coords.y->max;
+  if ((ops->coords.y->min <= 0.0) && (ops->axes.y->logScale))
+    extsPtr->top = Blt_FindElemValuesMinimum(ops->coords.y, DBL_MIN);
   else
-    extsPtr->top = elemPtr->coords.y->min;
+    extsPtr->top = ops->coords.y->min;
 
   // Correct the data limits for error bars
-  if (elemPtr->xError && elemPtr->xError->nValues > 0) {
+  if (ops->xError && ops->xError->nValues > 0) {
     int i;
 	
-    np = MIN(elemPtr->xError->nValues, np);
+    np = MIN(ops->xError->nValues, np);
     for (i = 0; i < np; i++) {
       double x;
 
-      x = elemPtr->coords.x->values[i] + elemPtr->xError->values[i];
+      x = ops->coords.x->values[i] + ops->xError->values[i];
       if (x > extsPtr->right) {
 	extsPtr->right = x;
       }
-      x = elemPtr->coords.x->values[i] - elemPtr->xError->values[i];
-      if (elemPtr->axes.x->logScale) {
+      x = ops->coords.x->values[i] - ops->xError->values[i];
+      if (ops->axes.x->logScale) {
 	// Mirror negative values, instead of ignoring them
 	if (x < 0.0)
 	  x = -x;
@@ -1701,38 +1730,38 @@ static void GetLineExtentsProc(Element *basePtr, Region2d *extsPtr)
     }		     
   }
   else {
-    if (elemPtr->xHigh && 
-	(elemPtr->xHigh->nValues > 0) && 
-	(elemPtr->xHigh->max > extsPtr->right)) {
-      extsPtr->right = elemPtr->xHigh->max;
+    if (ops->xHigh && 
+	(ops->xHigh->nValues > 0) && 
+	(ops->xHigh->max > extsPtr->right)) {
+      extsPtr->right = ops->xHigh->max;
     }
-    if (elemPtr->xLow && elemPtr->xLow->nValues > 0) {
+    if (ops->xLow && ops->xLow->nValues > 0) {
       double left;
 	    
-      if ((elemPtr->xLow->min <= 0.0) && 
-	  (elemPtr->axes.x->logScale))
-	left = Blt_FindElemValuesMinimum(elemPtr->xLow, DBL_MIN);
+      if ((ops->xLow->min <= 0.0) && 
+	  (ops->axes.x->logScale))
+	left = Blt_FindElemValuesMinimum(ops->xLow, DBL_MIN);
       else
-	left = elemPtr->xLow->min;
+	left = ops->xLow->min;
 
       if (left < extsPtr->left)
 	extsPtr->left = left;
     }
   }
     
-  if (elemPtr->yError && elemPtr->yError->nValues > 0) {
+  if (ops->yError && ops->yError->nValues > 0) {
     int i;
 	
-    np = MIN(elemPtr->yError->nValues, np);
+    np = MIN(ops->yError->nValues, np);
     for (i = 0; i < np; i++) {
       double y;
 
-      y = elemPtr->coords.y->values[i] + elemPtr->yError->values[i];
+      y = ops->coords.y->values[i] + ops->yError->values[i];
       if (y > extsPtr->bottom) {
 	extsPtr->bottom = y;
       }
-      y = elemPtr->coords.y->values[i] - elemPtr->yError->values[i];
-      if (elemPtr->axes.y->logScale) {
+      y = ops->coords.y->values[i] - ops->yError->values[i];
+      if (ops->axes.y->logScale) {
 	if (y < 0.0) {
 	  y = -y;		/* Mirror negative values, instead of
 				 * ignoring them. */
@@ -1745,19 +1774,19 @@ static void GetLineExtentsProc(Element *basePtr, Region2d *extsPtr)
       }
     }		     
   } else {
-    if (elemPtr->yHigh && 
-	(elemPtr->yHigh->nValues > 0) && 
-	(elemPtr->yHigh->max > extsPtr->bottom)) {
-      extsPtr->bottom = elemPtr->yHigh->max;
+    if (ops->yHigh && 
+	(ops->yHigh->nValues > 0) && 
+	(ops->yHigh->max > extsPtr->bottom)) {
+      extsPtr->bottom = ops->yHigh->max;
     }
-    if (elemPtr->yLow && elemPtr->yLow->nValues > 0) {
+    if (ops->yLow && ops->yLow->nValues > 0) {
       double top;
 	    
-      if ((elemPtr->yLow->min <= 0.0) && 
-	  (elemPtr->axes.y->logScale))
-	top = Blt_FindElemValuesMinimum(elemPtr->yLow, DBL_MIN);
+      if ((ops->yLow->min <= 0.0) && 
+	  (ops->axes.y->logScale))
+	top = Blt_FindElemValuesMinimum(ops->yLow, DBL_MIN);
       else
-	top = elemPtr->yLow->min;
+	top = ops->yLow->min;
 
       if (top < extsPtr->top)
 	extsPtr->top = top;
@@ -1765,19 +1794,22 @@ static void GetLineExtentsProc(Element *basePtr, Region2d *extsPtr)
   }
 }
 
-static void ClosestLineProc(Graph* graphPtr, Element *basePtr)
+static void ClosestLineProc(Graph* graphPtr, Element *elemPtr)
 {
+  LineElement* lePtr = (LineElement*)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
   ClosestSearch* searchPtr = &graphPtr->search;
-  LineElement* elemPtr = (LineElement *)basePtr;
   int mode = searchPtr->mode;
   if (mode == SEARCH_AUTO) {
-    LinePen* penPtr = NORMALPEN(elemPtr);
+    LinePen* penPtr = NORMALPEN(ops);
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
     mode = SEARCH_POINTS;
-    if ((NUMBEROFPOINTS(elemPtr) > 1) && (penPtr->traceWidth > 0))
+    if ((NUMBEROFPOINTS(ops) > 1) && (penOps->traceWidth > 0))
       mode = SEARCH_TRACES;
   }
   if (mode == SEARCH_POINTS)
-    ClosestPoint(elemPtr, searchPtr);
+    ClosestPoint(lePtr, searchPtr);
   else {
     DistanceProc *distProc;
     if (searchPtr->along == SEARCH_X)
@@ -1787,9 +1819,9 @@ static void ClosestLineProc(Graph* graphPtr, Element *basePtr)
     else
       distProc = DistanceToLineProc;
 
-    int found = ClosestTrace(graphPtr, elemPtr, distProc);
+    int found = ClosestTrace(graphPtr, lePtr, distProc);
     if ((!found) && (searchPtr->along != SEARCH_BOTH)) {
-      ClosestPoint(elemPtr, searchPtr);
+      ClosestPoint(lePtr, searchPtr);
     }
   }
 }
@@ -1810,18 +1842,20 @@ static void ClosestLineProc(Graph* graphPtr, Element *basePtr)
 #define MAX_DRAWARCS(d)		Blt_MaxRequestSize(d, sizeof(XArc))
 
 static void DrawCircles(Display *display, Drawable drawable, 
-			LineElement* elemPtr, LinePen* penPtr, 
+			LineElement* lePtr, LinePen* penPtr, 
 			int nSymbolPts, Point2d *symbolPts, int radius)
 {
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
   int count = 0;
   int s = radius + radius;
   XArc *arcs = (XArc*)malloc(nSymbolPts * sizeof(XArc));
 
-  if (elemPtr->symbolInterval > 0) {
+  if (lePtr->symbolInterval > 0) {
     XArc* ap = arcs;
     Point2d *pp, *pend;
     for (pp = symbolPts, pend = pp + nSymbolPts; pp < pend; pp++) {
-      if (DRAW_SYMBOL(elemPtr)) {
+      if (DRAW_SYMBOL(lePtr)) {
 	ap->x = Round(pp->x) - radius;
 	ap->y = Round(pp->y) - radius;
 	ap->width = ap->height = (unsigned short)s;
@@ -1829,7 +1863,7 @@ static void DrawCircles(Display *display, Drawable drawable,
 	ap->angle2 = 23040;
 	ap++, count++;
       }
-      elemPtr->symbolCounter++;
+      lePtr->symbolCounter++;
     }
   }
   else {
@@ -1849,35 +1883,37 @@ static void DrawCircles(Display *display, Drawable drawable,
   int reqSize = MAX_DRAWARCS(display);
   for (int ii=0; ii<count; ii+= reqSize) {
     int n = ((ii + reqSize) > count) ? (count - ii) : reqSize;
-    if (penPtr->symbol.fillGC)
-      XFillArcs(display, drawable, penPtr->symbol.fillGC, arcs + ii, n);
+    if (penOps->symbol.fillGC)
+      XFillArcs(display, drawable, penOps->symbol.fillGC, arcs + ii, n);
 
-    if (penPtr->symbol.outlineWidth > 0)
-      XDrawArcs(display, drawable, penPtr->symbol.outlineGC, arcs + ii, n);
+    if (penOps->symbol.outlineWidth > 0)
+      XDrawArcs(display, drawable, penOps->symbol.outlineGC, arcs + ii, n);
   }
 
   free(arcs);
 }
 
 static void DrawSquares(Display *display, Drawable drawable, 
-			LineElement* elemPtr, LinePen* penPtr, 
+			LineElement* lePtr, LinePen* penPtr, 
 			int nSymbolPts, Point2d *symbolPts, int r)
 {
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
   int count =0;
   int s = r + r;
   XRectangle *rectangles = (XRectangle*)malloc(nSymbolPts * sizeof(XRectangle));
 
-  if (elemPtr->symbolInterval > 0) {
+  if (lePtr->symbolInterval > 0) {
     XRectangle* rp = rectangles;
     Point2d *pp, *pend;
     for (pp = symbolPts, pend = pp + nSymbolPts; pp < pend; pp++) {
-      if (DRAW_SYMBOL(elemPtr)) {
+      if (DRAW_SYMBOL(lePtr)) {
 	rp->x = Round(pp->x) - r;
 	rp->y = Round(pp->y) - r;
 	rp->width = rp->height = (unsigned short)s;
 	rp++, count++;
       }
-      elemPtr->symbolCounter++;
+      lePtr->symbolCounter++;
     }
   }
   else {
@@ -1899,11 +1935,11 @@ static void DrawSquares(Display *display, Drawable drawable,
     if (n > reqSize)
       n = reqSize;
 
-    if (penPtr->symbol.fillGC)
-      XFillRectangles(display, drawable, penPtr->symbol.fillGC, rp, n);
+    if (penOps->symbol.fillGC)
+      XFillRectangles(display, drawable, penOps->symbol.fillGC, rp, n);
 
-    if (penPtr->symbol.outlineWidth > 0)
-      XDrawRectangles(display, drawable, penPtr->symbol.outlineGC, rp, n);
+    if (penOps->symbol.outlineWidth > 0)
+      XDrawRectangles(display, drawable, penOps->symbol.outlineGC, rp, n);
   }
 
   free(rectangles);
@@ -1912,14 +1948,16 @@ static void DrawSquares(Display *display, Drawable drawable,
 #define SQRT_PI		1.77245385090552
 #define S_RATIO		0.886226925452758
 static void DrawSymbols(Graph* graphPtr, Drawable drawable,
-			LineElement* elemPtr, LinePen* penPtr,
+			LineElement* lePtr, LinePen* penPtr,
 			int size, int nSymbolPts, Point2d *symbolPts)
 {
-  XPoint pattern[13];			/* Template for polygon symbols */
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
+  XPoint pattern[13];
   int count;
 
   if (size < 3) {
-    if (penPtr->symbol.fillGC) {
+    if (penOps->symbol.fillGC) {
       XPoint* points = (XPoint*)malloc(nSymbolPts * sizeof(XPoint));
       XPoint* xpp = points;
       Point2d *pp, *endp;
@@ -1928,7 +1966,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	xpp->y = Round(pp->y);
 	xpp++;
       }
-      XDrawPoints(graphPtr->display, drawable, penPtr->symbol.fillGC, 
+      XDrawPoints(graphPtr->display, drawable, penOps->symbol.fillGC, 
 		  points, nSymbolPts, CoordModeOrigin);
       free(points);
     }
@@ -1938,24 +1976,24 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
   int r1 = (int)ceil(size * 0.5);
   int r2 = (int)ceil(size * S_RATIO * 0.5);
 
-  switch (penPtr->symbol.type) {
+  switch (penOps->symbol.type) {
   case SYMBOL_NONE:
     break;
 
   case SYMBOL_SQUARE:
-    DrawSquares(graphPtr->display, drawable, elemPtr, penPtr, nSymbolPts,
+    DrawSquares(graphPtr->display, drawable, lePtr, penPtr, nSymbolPts,
 		symbolPts, r2);
     break;
 
   case SYMBOL_CIRCLE:
-    DrawCircles(graphPtr->display, drawable, elemPtr, penPtr, nSymbolPts,
+    DrawCircles(graphPtr->display, drawable, lePtr, penPtr, nSymbolPts,
 		symbolPts, r1);
     break;
 
   case SYMBOL_SPLUS:
   case SYMBOL_SCROSS:
     {
-      if (penPtr->symbol.type == SYMBOL_SCROSS) {
+      if (penOps->symbol.type == SYMBOL_SCROSS) {
 	r2 = Round((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;
@@ -1967,12 +2005,12 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
       }
 
       XSegment *segments = (XSegment*)malloc(nSymbolPts * 2 * sizeof(XSegment));
-      if (elemPtr->symbolInterval > 0) {
+      if (lePtr->symbolInterval > 0) {
 	XSegment* sp = segments;
 	count = 0;
 	Point2d *pp, *endp;
 	for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) {
-	  if (DRAW_SYMBOL(elemPtr)) {
+	  if (DRAW_SYMBOL(lePtr)) {
 	    int rndx, rndy;
 	    rndx = Round(pp->x), rndy = Round(pp->y);
 	    sp->x1 = pattern[0].x + rndx;
@@ -1987,7 +2025,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	    sp++;
 	    count++;
 	  }
-	  elemPtr->symbolCounter++;
+	  lePtr->symbolCounter++;
 	}
       }
       else {
@@ -2015,7 +2053,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
       for (int ii=0; ii<nSegs; ii+=reqSize) {
 	int chunk = ((ii + reqSize) > nSegs) ? (nSegs - ii) : reqSize;
 	XDrawSegments(graphPtr->display, drawable, 
-		      penPtr->symbol.outlineGC, segments + ii, chunk);
+		      penOps->symbol.outlineGC, segments + ii, chunk);
       }
       free(segments);
     }
@@ -2051,7 +2089,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
       pattern[11].y = pattern[10].y = pattern[7].y = pattern[6].y = d;
       pattern[9].y = pattern[8].y = r2;
 
-      if (penPtr->symbol.type == SYMBOL_CROSS) {
+      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;
@@ -2062,12 +2100,12 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	pattern[12] = pattern[0];
       }
       polygon = (XPoint*)malloc(nSymbolPts * 13 * sizeof(XPoint));
-      if (elemPtr->symbolInterval > 0) {
+      if (lePtr->symbolInterval > 0) {
 	count = 0;
 	XPoint* xpp = polygon;
 	Point2d *pp, *endp;
 	for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) {
-	  if (DRAW_SYMBOL(elemPtr)) {
+	  if (DRAW_SYMBOL(lePtr)) {
 	    int rndx = Round(pp->x);
 	    int rndy = Round(pp->y);
 	    for (int ii=0; ii<13; ii++) {
@@ -2077,7 +2115,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	    }
 	    count++;
 	  }
-	  elemPtr->symbolCounter++;
+	  lePtr->symbolCounter++;
 	}
       }
       else {
@@ -2094,20 +2132,20 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	}
 	count = nSymbolPts;
       }
-      if (penPtr->symbol.fillGC) {
+      if (penOps->symbol.fillGC) {
 	int ii;
 	XPoint *xpp;
 	for (xpp = polygon, ii = 0; ii<count; ii++, xpp += 13)
 	  XFillPolygon(graphPtr->display, drawable, 
-		       penPtr->symbol.fillGC, xpp, 13, Complex, 
+		       penOps->symbol.fillGC, xpp, 13, Complex, 
 		       CoordModeOrigin);
       }
-      if (penPtr->symbol.outlineWidth > 0) {
+      if (penOps->symbol.outlineWidth > 0) {
 	int ii;
 	XPoint *xpp;
 	for (xpp = polygon, ii=0; ii<count; ii++, xpp += 13)
 	  XDrawLines(graphPtr->display, drawable, 
-		     penPtr->symbol.outlineGC, xpp, 13, CoordModeOrigin);
+		     penOps->symbol.outlineGC, xpp, 13, CoordModeOrigin);
       }
       free(polygon);
     }
@@ -2133,7 +2171,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
       pattern[4] = pattern[0];
 
       polygon = (XPoint*)malloc(nSymbolPts * 5 * sizeof(XPoint));
-      if (elemPtr->symbolInterval > 0) {
+      if (lePtr->symbolInterval > 0) {
 	Point2d *pp, *endp;
 	XPoint *xpp;
 
@@ -2142,7 +2180,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) {
 	  int i;
 
-	  if (DRAW_SYMBOL(elemPtr)) {
+	  if (DRAW_SYMBOL(lePtr)) {
 	    int rndx, rndy;
 			
 	    rndx = Round(pp->x), rndy = Round(pp->y);
@@ -2153,7 +2191,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	    }
 	    count++;
 	  }
-	  elemPtr->symbolCounter++;
+	  lePtr->symbolCounter++;
 	}
       } else {
 	Point2d *pp, *endp;
@@ -2173,21 +2211,21 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	}
 	count = nSymbolPts;
       }
-      if (penPtr->symbol.fillGC) {
+      if (penOps->symbol.fillGC) {
 	XPoint *xpp;
 	int i;
 
 	for (xpp = polygon, i = 0; i < count; i++, xpp += 5)
 	  XFillPolygon(graphPtr->display, drawable, 
-		       penPtr->symbol.fillGC, xpp, 5, Convex, CoordModeOrigin);
+		       penOps->symbol.fillGC, xpp, 5, Convex, CoordModeOrigin);
       }
-      if (penPtr->symbol.outlineWidth > 0) {
+      if (penOps->symbol.outlineWidth > 0) {
 	XPoint *xpp;
 	int i;
 
 	for (xpp = polygon, i = 0; i < count; i++, xpp += 5) {
 	  XDrawLines(graphPtr->display, drawable, 
-		     penPtr->symbol.outlineGC, xpp, 5, CoordModeOrigin);
+		     penOps->symbol.outlineGC, xpp, 5, CoordModeOrigin);
 	}
       }
       free(polygon);
@@ -2220,7 +2258,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
        *
        */
 
-      if (penPtr->symbol.type == SYMBOL_ARROW) {
+      if (penOps->symbol.type == SYMBOL_ARROW) {
 	pattern[3].x = pattern[0].x = 0;
 	pattern[3].y = pattern[0].y = h1;
 	pattern[1].x = b2;
@@ -2234,7 +2272,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	pattern[2].x = -b2;
       }
       polygon = (XPoint*)malloc(nSymbolPts * 4 * sizeof(XPoint));
-      if (elemPtr->symbolInterval > 0) {
+      if (lePtr->symbolInterval > 0) {
 	Point2d *pp, *endp;
 	XPoint *xpp;
 
@@ -2243,7 +2281,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) {
 	  int i;
 
-	  if (DRAW_SYMBOL(elemPtr)) {
+	  if (DRAW_SYMBOL(lePtr)) {
 	    int rndx, rndy;
 
 	    rndx = Round(pp->x), rndy = Round(pp->y);
@@ -2254,7 +2292,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	    }
 	    count++;
 	  }
-	  elemPtr->symbolCounter++;
+	  lePtr->symbolCounter++;
 	}
       } else {
 	Point2d *pp, *endp;
@@ -2274,23 +2312,23 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	}
 	count = nSymbolPts;
       }
-      if (penPtr->symbol.fillGC) {
+      if (penOps->symbol.fillGC) {
 	XPoint *xpp;
 	int i;
 
 	xpp = polygon;
 	for (xpp = polygon, i = 0; i < count; i++, xpp += 4)
 	  XFillPolygon(graphPtr->display, drawable, 
-		       penPtr->symbol.fillGC, xpp, 4, Convex, CoordModeOrigin);
+		       penOps->symbol.fillGC, xpp, 4, Convex, CoordModeOrigin);
       }
-      if (penPtr->symbol.outlineWidth > 0) {
+      if (penOps->symbol.outlineWidth > 0) {
 	XPoint *xpp;
 	int i;
 
 	xpp = polygon;
 	for (xpp = polygon, i = 0; i < count; i++, xpp += 4) {
 	  XDrawLines(graphPtr->display, drawable, 
-		     penPtr->symbol.outlineGC, xpp, 4, CoordModeOrigin);
+		     penOps->symbol.outlineGC, xpp, 4, CoordModeOrigin);
 	}
       }
       free(polygon);
@@ -2303,7 +2341,7 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
       double scale, sx, sy;
       int dx, dy;
 
-      Tk_SizeOfBitmap(graphPtr->display, penPtr->symbol.bitmap, &w, &h);
+      Tk_SizeOfBitmap(graphPtr->display, penOps->symbol.bitmap, &w, &h);
 
       // Compute the size of the scaled bitmap.  Stretch the bitmap to fit
       // a nxn bounding box.
@@ -2313,32 +2351,32 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
       bw = (int)(w * scale);
       bh = (int)(h * scale);
 
-      XSetClipMask(graphPtr->display, penPtr->symbol.outlineGC, None);
-      if (penPtr->symbol.mask != None)
-	XSetClipMask(graphPtr->display, penPtr->symbol.outlineGC,
-		     penPtr->symbol.mask);
+      XSetClipMask(graphPtr->display, penOps->symbol.outlineGC, None);
+      if (penOps->symbol.mask != None)
+	XSetClipMask(graphPtr->display, penOps->symbol.outlineGC,
+		     penOps->symbol.mask);
 
-      if (penPtr->symbol.fillGC == NULL)
-	XSetClipMask(graphPtr->display, penPtr->symbol.outlineGC, 
-		     penPtr->symbol.bitmap);
+      if (penOps->symbol.fillGC == NULL)
+	XSetClipMask(graphPtr->display, penOps->symbol.outlineGC, 
+		     penOps->symbol.bitmap);
 
       dx = bw / 2;
       dy = bh / 2;
 
-      if (elemPtr->symbolInterval > 0) {
+      if (lePtr->symbolInterval > 0) {
 	Point2d *pp, *endp;
 	for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) {
-	  if (DRAW_SYMBOL(elemPtr)) {
+	  if (DRAW_SYMBOL(lePtr)) {
 	    int x = Round(pp->x) - dx;
 	    int y = Round(pp->y) - dy;
-	    if ((penPtr->symbol.fillGC == NULL) || 
-		(penPtr->symbol.mask != None))
+	    if ((penOps->symbol.fillGC == NULL) || 
+		(penOps->symbol.mask != None))
 	      XSetClipOrigin(graphPtr->display,
-			     penPtr->symbol.outlineGC, x, y);
-	    XCopyPlane(graphPtr->display, penPtr->symbol.bitmap, drawable,
-		       penPtr->symbol.outlineGC, 0, 0, bw, bh, x, y, 1);
+			     penOps->symbol.outlineGC, x, y);
+	    XCopyPlane(graphPtr->display, penOps->symbol.bitmap, drawable,
+		       penOps->symbol.outlineGC, 0, 0, bw, bh, x, y, 1);
 	  }
-	  elemPtr->symbolCounter++;
+	  lePtr->symbolCounter++;
 	}
       }
       else {
@@ -2346,12 +2384,12 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 	for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) {
 	  int x = Round(pp->x) - dx;
 	  int y = Round(pp->y) - dy;
-	  if ((penPtr->symbol.fillGC == NULL) || 
-	      (penPtr->symbol.mask != None))
+	  if ((penOps->symbol.fillGC == NULL) || 
+	      (penOps->symbol.mask != None))
 	    XSetClipOrigin(graphPtr->display, 
-			   penPtr->symbol.outlineGC, x, y);
-	  XCopyPlane(graphPtr->display, penPtr->symbol.bitmap, drawable,
-		     penPtr->symbol.outlineGC, 0, 0, bw, bh, x, y, 1);
+			   penOps->symbol.outlineGC, x, y);
+	  XCopyPlane(graphPtr->display, penOps->symbol.bitmap, drawable,
+		     penOps->symbol.outlineGC, 0, 0, bw, bh, x, y, 1);
 	}
       }
     }
@@ -2360,13 +2398,15 @@ static void DrawSymbols(Graph* graphPtr, Drawable drawable,
 }
 
 static void DrawSymbolProc(Graph* graphPtr, Drawable drawable,
-			   Element *basePtr, int x, int y, int size)
+			   Element *elemPtr, int x, int y, int size)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
-  LinePen* penPtr;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
+  LinePen* penPtr = NORMALPEN(ops);
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
 
-  penPtr = NORMALPEN(elemPtr);
-  if (penPtr->traceWidth > 0) {
+  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
@@ -2377,16 +2417,16 @@ static void DrawSymbolProc(Graph* graphPtr, Drawable drawable,
     XDrawLine(graphPtr->display, drawable, penPtr->traceGC, x - size, y + 1,
 	      x + size, y + 1);
   }
-  if (penPtr->symbol.type != SYMBOL_NONE) {
+  if (penOps->symbol.type != SYMBOL_NONE) {
     Point2d point;
 
     point.x = x, point.y = y;
-    DrawSymbols(graphPtr, drawable, elemPtr, penPtr, size, 1, &point);
+    DrawSymbols(graphPtr, drawable, lePtr, penPtr, size, 1, &point);
   }
 }
 
 static void DrawTraces(Graph* graphPtr, Drawable drawable, 
-		       LineElement* elemPtr, LinePen* penPtr)
+		       LineElement* lePtr, LinePen* penPtr)
 {
   Blt_ChainLink link;
   int np;
@@ -2394,7 +2434,7 @@ static void DrawTraces(Graph* graphPtr, Drawable drawable,
   np = Blt_MaxRequestSize(graphPtr->display, sizeof(XPoint)) - 1;
   XPoint *points = (XPoint*)malloc((np + 1) * sizeof(XPoint));
 	    
-  for (link = Blt_Chain_FirstLink(elemPtr->traces); link;
+  for (link = Blt_Chain_FirstLink(lePtr->traces); link;
        link = Blt_Chain_NextLink(link)) {
     XPoint *xpp;
     int remaining, count;
@@ -2455,54 +2495,59 @@ static void DrawTraces(Graph* graphPtr, Drawable drawable,
 }
 
 static void DrawValues(Graph* graphPtr, Drawable drawable, 
-		       LineElement* elemPtr, LinePen* penPtr, 
+		       LineElement* lePtr, LinePen* penPtr, 
 		       int length, Point2d *points, int *map)
 {
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
   Point2d *pp, *endp;
   double *xval, *yval;
   const char* fmt;
   char string[TCL_DOUBLE_SPACE * 2 + 2];
   int count;
     
-  fmt = penPtr->valueFormat;
-  if (fmt == NULL) {
+  fmt = penOps->valueFormat;
+  if (fmt == NULL)
     fmt = "%g";
-  }
+
   count = 0;
-  xval = elemPtr->coords.x->values, yval = elemPtr->coords.y->values;
+  xval = ops->coords.x->values, yval = ops->coords.y->values;
 
   // be sure to update style->gc, things might have changed
-  penPtr->valueStyle.flags |= UPDATE_GC;
+  penOps->valueStyle.flags |= UPDATE_GC;
   for (pp = points, endp = points + length; pp < endp; pp++) {
     double x, y;
 
     x = xval[map[count]];
     y = yval[map[count]];
     count++;
-    if (penPtr->valueShow == SHOW_X) {
+    if (penOps->valueShow == SHOW_X) {
       sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); 
-    } else if (penPtr->valueShow == SHOW_Y) {
+    } else if (penOps->valueShow == SHOW_Y) {
       sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); 
-    } else if (penPtr->valueShow == SHOW_BOTH) {
+    } else if (penOps->valueShow == SHOW_BOTH) {
       sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x);
       strcat(string, ",");
       sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
     }
-    Blt_DrawText(graphPtr->tkwin, drawable, string, &penPtr->valueStyle, 
+    Blt_DrawText(graphPtr->tkwin, drawable, string, &penOps->valueStyle, 
 		 Round(pp->x), Round(pp->y));
   } 
 }
 
 static void DrawActiveLineProc(Graph* graphPtr, Drawable drawable, 
-			       Element *basePtr)
+			       Element *elemPtr)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
-  LinePen* penPtr = (LinePen *)elemPtr->activePenPtr;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+  LinePen* penPtr = (LinePen *)ops->activePenPtr;
 
   if (!penPtr)
     return;
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
 
-  int symbolSize = ScaleSymbol(elemPtr, penPtr->symbol.size);
+  int symbolSize = ScaleSymbol(lePtr, penOps->symbol.size);
 
   /* 
    * nActiveIndices 
@@ -2510,151 +2555,154 @@ static void DrawActiveLineProc(Graph* graphPtr, Drawable drawable,
    *	  < 0		All points are active.
    *    == 0		No points are active.
    */
-  if (elemPtr->nActiveIndices > 0) {
-    if (elemPtr->flags & ACTIVE_PENDING) {
-      MapActiveSymbols(graphPtr, elemPtr);
-    }
-    if (penPtr->symbol.type != SYMBOL_NONE) {
-      DrawSymbols(graphPtr, drawable, elemPtr, penPtr, symbolSize,
-		  elemPtr->activePts.length, elemPtr->activePts.points);
-    }
-    if (penPtr->valueShow != SHOW_NONE) {
-      DrawValues(graphPtr, drawable, elemPtr, penPtr, 
-		 elemPtr->activePts.length,
-		 elemPtr->activePts.points, 
-		 elemPtr->activePts.map);
-    }
-  } else if (elemPtr->nActiveIndices < 0) { 
-    if (penPtr->traceWidth > 0) {
-      if (elemPtr->lines.length > 0) {
+  if (lePtr->nActiveIndices > 0) {
+    if (lePtr->flags & ACTIVE_PENDING) {
+      MapActiveSymbols(graphPtr, lePtr);
+    }
+    if (penOps->symbol.type != SYMBOL_NONE) {
+      DrawSymbols(graphPtr, drawable, lePtr, penPtr, symbolSize,
+		  lePtr->activePts.length, lePtr->activePts.points);
+    }
+    if (penOps->valueShow != SHOW_NONE) {
+      DrawValues(graphPtr, drawable, lePtr, penPtr, 
+		 lePtr->activePts.length,
+		 lePtr->activePts.points, 
+		 lePtr->activePts.map);
+    }
+  } else if (lePtr->nActiveIndices < 0) { 
+    if (penOps->traceWidth > 0) {
+      if (lePtr->lines.length > 0) {
 	Blt_Draw2DSegments(graphPtr->display, drawable, 
-			   penPtr->traceGC, elemPtr->lines.segments, 
-			   elemPtr->lines.length);
-      } else if (Blt_Chain_GetLength(elemPtr->traces) > 0) {
-	DrawTraces(graphPtr, drawable, elemPtr, penPtr);
+			   penPtr->traceGC, lePtr->lines.segments, 
+			   lePtr->lines.length);
+      } else if (Blt_Chain_GetLength(lePtr->traces) > 0) {
+	DrawTraces(graphPtr, drawable, lePtr, penPtr);
       }
     }
-    if (penPtr->symbol.type != SYMBOL_NONE) {
-      DrawSymbols(graphPtr, drawable, elemPtr, penPtr, symbolSize,
-		  elemPtr->symbolPts.length, elemPtr->symbolPts.points);
+    if (penOps->symbol.type != SYMBOL_NONE) {
+      DrawSymbols(graphPtr, drawable, lePtr, penPtr, symbolSize,
+		  lePtr->symbolPts.length, lePtr->symbolPts.points);
     }
-    if (penPtr->valueShow != SHOW_NONE) {
-      DrawValues(graphPtr, drawable, elemPtr, penPtr, 
-		 elemPtr->symbolPts.length, elemPtr->symbolPts.points, 
-		 elemPtr->symbolPts.map);
+    if (penOps->valueShow != SHOW_NONE) {
+      DrawValues(graphPtr, drawable, lePtr, penPtr, 
+		 lePtr->symbolPts.length, lePtr->symbolPts.points, 
+		 lePtr->symbolPts.map);
     }
   }
 }
 
 static void DrawNormalLineProc(Graph* graphPtr, Drawable drawable, 
-			       Element *basePtr)
+			       Element *elemPtr)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
-  Blt_ChainLink link;
-  unsigned int count;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
-  /* Fill area under the curve */
-  if (elemPtr->fillPts) {
-    Point2d *endp, *pp;
+  // Fill area under the curve
+  if (lePtr->fillPts) {
+    XPoint *points = (XPoint*)malloc(sizeof(XPoint) * lePtr->nFillPts);
 
-    XPoint *points = (XPoint*)malloc(sizeof(XPoint) * elemPtr->nFillPts);
-    count = 0;
-    for (pp = elemPtr->fillPts, endp = pp + elemPtr->nFillPts; 
+    unsigned int count =0;
+    Point2d *endp, *pp;
+    for (pp = lePtr->fillPts, endp = pp + lePtr->nFillPts; 
 	 pp < endp; pp++) {
       points[count].x = Round(pp->x);
       points[count].y = Round(pp->y);
       count++;
     }
-    if (elemPtr->fillBg) {
-      Tk_Fill3DPolygon(graphPtr->tkwin, drawable, 
-		       elemPtr->fillBg, points, 
-		       elemPtr->nFillPts, 0, TK_RELIEF_FLAT);
-    }
+    if (ops->fillBg)
+      Tk_Fill3DPolygon(graphPtr->tkwin, drawable, ops->fillBg, points, 
+		       lePtr->nFillPts, 0, TK_RELIEF_FLAT);
     free(points);
   }
 
-  /* Lines: stripchart segments or graph traces. */
-  if (elemPtr->lines.length > 0) {
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
+  // Lines: stripchart segments or graph traces
+  if (lePtr->lines.length > 0) {
+    for (Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette); 
 	 link; link = Blt_Chain_NextLink(link)) {
 
       LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
       LinePen* penPtr = (LinePen *)stylePtr->penPtr;
+      LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
       if ((stylePtr->lines.length > 0) && 
-	  (penPtr->errorBarLineWidth > 0)) {
+	  (penOps->errorBarLineWidth > 0)) {
 	Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->traceGC,
 			   stylePtr->lines.segments, stylePtr->lines.length);
       }
     }
-  } else {
-    LinePen* penPtr;
+  } 
+  else {
+    LinePen* penPtr = NORMALPEN(ops);
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
 
-    penPtr = NORMALPEN(elemPtr);
-    if ((Blt_Chain_GetLength(elemPtr->traces) > 0) && 
-	(penPtr->traceWidth > 0)) {
-      DrawTraces(graphPtr, drawable, elemPtr, penPtr);
+    if ((Blt_Chain_GetLength(lePtr->traces) > 0) && 
+	(penOps->traceWidth > 0)) {
+      DrawTraces(graphPtr, drawable, lePtr, penPtr);
     }
   }
 
-  if (elemPtr->reqMaxSymbols > 0) {
+  if (ops->reqMaxSymbols > 0) {
     int total = 0;
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
+    for (Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette); 
 	 link; link = Blt_Chain_NextLink(link)) {
       LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
       total += stylePtr->symbolPts.length;
     }
-    elemPtr->symbolInterval = total / elemPtr->reqMaxSymbols;
-    elemPtr->symbolCounter = 0;
+    lePtr->symbolInterval = total / ops->reqMaxSymbols;
+    lePtr->symbolCounter = 0;
   }
 
-  /* Symbols, error bars, values. */
+  // Symbols, error bars, values
 
-  count = 0;
-  for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link;
+  unsigned int count =0;
+  for (Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette); link;
        link = Blt_Chain_NextLink(link)) {
     LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
     LinePen* penPtr = (LinePen *)stylePtr->penPtr;
-    if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) {
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
+    if ((stylePtr->xeb.length > 0) && (penOps->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)) {
+
+    if ((stylePtr->yeb.length > 0) && (penOps->errorBarShow & SHOW_Y))
       Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, 
 			 stylePtr->yeb.segments, stylePtr->yeb.length);
-    }
+
     if ((stylePtr->symbolPts.length > 0) && 
-	(penPtr->symbol.type != SYMBOL_NONE)) {
-      DrawSymbols(graphPtr, drawable, elemPtr, penPtr, 
+	(penOps->symbol.type != SYMBOL_NONE))
+      DrawSymbols(graphPtr, drawable, lePtr, penPtr, 
 		  stylePtr->symbolSize, stylePtr->symbolPts.length, 
 		  stylePtr->symbolPts.points);
-    }
-    if (penPtr->valueShow != SHOW_NONE) {
-      DrawValues(graphPtr, drawable, elemPtr, penPtr, 
+
+    if (penOps->valueShow != SHOW_NONE)
+      DrawValues(graphPtr, drawable, lePtr, penPtr, 
 		 stylePtr->symbolPts.length, stylePtr->symbolPts.points, 
-		 elemPtr->symbolPts.map + count);
-    }
+		 lePtr->symbolPts.map + count);
+
     count += stylePtr->symbolPts.length;
   }
-  elemPtr->symbolInterval = 0;
+  lePtr->symbolInterval = 0;
 }
 
 static void GetSymbolPostScriptInfo(Graph* graphPtr, Blt_Ps ps,
 				    LinePen* penPtr, int size)
 {
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
   /* Set line and foreground attributes */
-  XColor* fillColor = penPtr->symbol.fillColor;
+  XColor* fillColor = penOps->symbol.fillColor;
   if (!fillColor)
-    fillColor = penPtr->traceColor;
+    fillColor = penOps->traceColor;
 
-  XColor* outlineColor = penPtr->symbol.outlineColor;
+  XColor* outlineColor = penOps->symbol.outlineColor;
   if (!outlineColor)
-    outlineColor = penPtr->traceColor;
+    outlineColor = penOps->traceColor;
 
-  if (penPtr->symbol.type == SYMBOL_NONE)
-    Blt_Ps_XSetLineAttributes(ps, penPtr->traceColor, penPtr->traceWidth + 2,
-			      &penPtr->traceDashes, CapButt, JoinMiter);
+  if (penOps->symbol.type == SYMBOL_NONE)
+    Blt_Ps_XSetLineAttributes(ps, penOps->traceColor, penOps->traceWidth + 2,
+			      &penOps->traceDashes, CapButt, JoinMiter);
   else {
-    Blt_Ps_XSetLineWidth(ps, penPtr->symbol.outlineWidth);
+    Blt_Ps_XSetLineWidth(ps, penOps->symbol.outlineWidth);
     Blt_Ps_XSetDashes(ps, (Blt_Dashes *)NULL);
   }
 
@@ -2664,7 +2712,7 @@ static void GetSymbolPostScriptInfo(Graph* graphPtr, Blt_Ps ps,
    * already.
    */
   Blt_Ps_Append(ps, "\n/DrawSymbolProc {\n");
-  switch (penPtr->symbol.type) {
+  switch (penOps->symbol.type) {
   case SYMBOL_NONE:
     break;				/* Do nothing */
   case SYMBOL_BITMAP:
@@ -2676,24 +2724,24 @@ static void GetSymbolPostScriptInfo(Graph* graphPtr, Blt_Ps ps,
        * Compute how much to scale the bitmap.  Don't let the scaled
        * bitmap exceed the bounding square for the symbol.
        */
-      Tk_SizeOfBitmap(graphPtr->display, penPtr->symbol.bitmap, &w, &h);
+      Tk_SizeOfBitmap(graphPtr->display, penOps->symbol.bitmap, &w, &h);
       sx = (double)size / (double)w;
       sy = (double)size / (double)h;
       scale = MIN(sx, sy);
 
-      if (penPtr->symbol.mask != None) {
+      if (penOps->symbol.mask != None) {
 	Blt_Ps_VarAppend(ps, "\n  % Bitmap mask is \"",
-			 Tk_NameOfBitmap(graphPtr->display, penPtr->symbol.mask),
+			 Tk_NameOfBitmap(graphPtr->display, penOps->symbol.mask),
 			 "\"\n\n  ", NULL);
 	Blt_Ps_XSetBackground(ps, fillColor);
-	Blt_Ps_DrawBitmap(ps, graphPtr->display, penPtr->symbol.mask, 
+	Blt_Ps_DrawBitmap(ps, graphPtr->display, penOps->symbol.mask, 
 			  scale, scale);
       }
       Blt_Ps_VarAppend(ps, "\n  % Bitmap symbol is \"",
-		       Tk_NameOfBitmap(graphPtr->display, penPtr->symbol.bitmap),
+		       Tk_NameOfBitmap(graphPtr->display, penOps->symbol.bitmap),
 		       "\"\n\n  ", NULL);
       Blt_Ps_XSetForeground(ps, outlineColor);
-      Blt_Ps_DrawBitmap(ps, graphPtr->display, penPtr->symbol.bitmap, 
+      Blt_Ps_DrawBitmap(ps, graphPtr->display, penOps->symbol.bitmap, 
 			scale, scale);
     }
     break;
@@ -2702,7 +2750,7 @@ static void GetSymbolPostScriptInfo(Graph* graphPtr, Blt_Ps ps,
     Blt_Ps_XSetBackground(ps, fillColor);
     Blt_Ps_Append(ps, "  gsave fill grestore\n");
 
-    if (penPtr->symbol.outlineWidth > 0) {
+    if (penOps->symbol.outlineWidth > 0) {
       Blt_Ps_Append(ps, "  ");
       Blt_Ps_XSetForeground(ps, outlineColor);
       Blt_Ps_Append(ps, "  stroke\n");
@@ -2715,6 +2763,8 @@ static void GetSymbolPostScriptInfo(Graph* graphPtr, Blt_Ps ps,
 static void SymbolsToPostScript(Graph* graphPtr, Blt_Ps ps, LinePen* penPtr,
 				int size, int nSymbolPts, Point2d *symbolPts)
 {
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
   double symbolSize;
   static const char* symbolMacros[] =
     {
@@ -2723,7 +2773,7 @@ static void SymbolsToPostScript(Graph* graphPtr, Blt_Ps ps, LinePen* penPtr,
   GetSymbolPostScriptInfo(graphPtr, ps, penPtr, size);
 
   symbolSize = (double)size;
-  switch (penPtr->symbol.type) {
+  switch (penOps->symbol.type) {
   case SYMBOL_SQUARE:
   case SYMBOL_CROSS:
   case SYMBOL_PLUS:
@@ -2747,30 +2797,32 @@ static void SymbolsToPostScript(Graph* graphPtr, Blt_Ps ps, LinePen* penPtr,
 
     for (pp = symbolPts, endp = symbolPts + nSymbolPts; pp < endp; pp++) {
       Blt_Ps_Format(ps, "%g %g %g %s\n", pp->x, pp->y, 
-		    symbolSize, symbolMacros[penPtr->symbol.type]);
+		    symbolSize, symbolMacros[penOps->symbol.type]);
     }
   }
 }
 
 static void SymbolToPostScriptProc(Graph* graphPtr, Blt_Ps ps,
-				   Element *basePtr, double x, double y,
+				   Element *elemPtr, double x, double y,
 				   int size)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
-  LinePen* penPtr;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+
+  LinePen* penPtr = NORMALPEN(ops);
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
 
-  penPtr = NORMALPEN(elemPtr);
-  if (penPtr->traceWidth > 0) {
+  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.
      */
-    Blt_Ps_XSetLineAttributes(ps, penPtr->traceColor, penPtr->traceWidth, 
-			      &penPtr->traceDashes, CapButt, JoinMiter);
+    Blt_Ps_XSetLineAttributes(ps, penOps->traceColor, penOps->traceWidth, 
+			      &penOps->traceDashes, CapButt, JoinMiter);
     Blt_Ps_Format(ps, "%g %g %d Li\n", x, y, size + size);
   }
-  if (penPtr->symbol.type != SYMBOL_NONE) {
+  if (penOps->symbol.type != SYMBOL_NONE) {
     Point2d point;
 
     point.x = x, point.y = y;
@@ -2780,13 +2832,15 @@ static void SymbolToPostScriptProc(Graph* graphPtr, Blt_Ps ps,
 
 static void SetLineAttributes(Blt_Ps ps, LinePen* penPtr)
 {
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
   /* Set the attributes of the line (color, dashes, linewidth) */
-  Blt_Ps_XSetLineAttributes(ps, penPtr->traceColor, penPtr->traceWidth, 
-			    &penPtr->traceDashes, CapButt, JoinMiter);
-  if ((LineIsDashed(penPtr->traceDashes)) && 
-      (penPtr->traceOffColor)) {
+  Blt_Ps_XSetLineAttributes(ps, penOps->traceColor, penOps->traceWidth, 
+			    &penOps->traceDashes, CapButt, JoinMiter);
+  if ((LineIsDashed(penOps->traceDashes)) && 
+      (penOps->traceOffColor)) {
     Blt_Ps_Append(ps, "/DashesProc {\n  gsave\n    ");
-    Blt_Ps_XSetBackground(ps, penPtr->traceOffColor);
+    Blt_Ps_XSetBackground(ps, penOps->traceOffColor);
     Blt_Ps_Append(ps, "    ");
     Blt_Ps_XSetDashes(ps, (Blt_Dashes *)NULL);
     Blt_Ps_Append(ps, "stroke\n  grestore\n} def\n");
@@ -2795,12 +2849,12 @@ static void SetLineAttributes(Blt_Ps ps, LinePen* penPtr)
   }
 }
 
-static void TracesToPostScript(Blt_Ps ps, LineElement* elemPtr, LinePen* penPtr)
+static void TracesToPostScript(Blt_Ps ps, LineElement* lePtr, LinePen* penPtr)
 {
   Blt_ChainLink link;
 
   SetLineAttributes(ps, penPtr);
-  for (link = Blt_Chain_FirstLink(elemPtr->traces); link;
+  for (link = Blt_Chain_FirstLink(lePtr->traces); link;
        link = Blt_Chain_NextLink(link)) {
     bltTrace *tracePtr = (bltTrace*)Blt_Chain_GetValue(link);
     if (tracePtr->screenPts.length > 0) {
@@ -2812,120 +2866,123 @@ static void TracesToPostScript(Blt_Ps ps, LineElement* elemPtr, LinePen* penPtr)
   }
 }
 
-static void ValuesToPostScript(Blt_Ps ps, LineElement* elemPtr, LinePen* penPtr,
+static void ValuesToPostScript(Blt_Ps ps, LineElement* lePtr, LinePen* penPtr,
 			       int nSymbolPts, Point2d *symbolPts, 
 			       int *pointToData)
 {
-  Point2d *pp, *endp;
-  int count;
-  char string[TCL_DOUBLE_SPACE * 2 + 2];
-  const char* fmt;
-    
-  fmt = penPtr->valueFormat;
-  if (fmt == NULL) {
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
+  const char* fmt = penOps->valueFormat;
+  if (fmt == NULL)
     fmt = "%g";
-  }
-  count = 0;
+
+  int count = 0;
+  Point2d *pp, *endp;
   for (pp = symbolPts, endp = symbolPts + nSymbolPts; pp < endp; pp++) {
     double x, y;
 
-    x = elemPtr->coords.x->values[pointToData[count]];
-    y = elemPtr->coords.y->values[pointToData[count]];
+    x = ops->coords.x->values[pointToData[count]];
+    y = ops->coords.y->values[pointToData[count]];
     count++;
-    if (penPtr->valueShow == SHOW_X) {
+
+    char string[TCL_DOUBLE_SPACE * 2 + 2];
+    if (penOps->valueShow == SHOW_X) {
       sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); 
-    } else if (penPtr->valueShow == SHOW_Y) {
+    } else if (penOps->valueShow == SHOW_Y) {
       sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); 
-    } else if (penPtr->valueShow == SHOW_BOTH) {
+    } else if (penOps->valueShow == SHOW_BOTH) {
       sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x);
       strcat(string, ",");
       sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y);
     }
-    Blt_Ps_DrawText(ps, string, &penPtr->valueStyle, pp->x, pp->y);
+    Blt_Ps_DrawText(ps, string, &penOps->valueStyle, pp->x, pp->y);
   } 
 }
 
 static void ActiveLineToPostScriptProc(Graph* graphPtr, Blt_Ps ps, 
-				       Element *basePtr)
+				       Element *elemPtr)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
-  LinePen* penPtr = (LinePen *)elemPtr->activePenPtr;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
+  LinePen* penPtr = (LinePen *)ops->activePenPtr;
   if (!penPtr)
     return;
+  LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
 
-  int symbolSize = ScaleSymbol(elemPtr, penPtr->symbol.size);
-  if (elemPtr->nActiveIndices > 0) {
-    if (elemPtr->flags & ACTIVE_PENDING) {
-      MapActiveSymbols(graphPtr, elemPtr);
+  int symbolSize = ScaleSymbol(lePtr, penOps->symbol.size);
+  if (lePtr->nActiveIndices > 0) {
+    if (lePtr->flags & ACTIVE_PENDING) {
+      MapActiveSymbols(graphPtr, lePtr);
     }
-    if (penPtr->symbol.type != SYMBOL_NONE) {
+    if (penOps->symbol.type != SYMBOL_NONE) {
       SymbolsToPostScript(graphPtr, ps, penPtr, symbolSize,
-			  elemPtr->activePts.length, elemPtr->activePts.points);
+			  lePtr->activePts.length, lePtr->activePts.points);
     }
-    if (penPtr->valueShow != SHOW_NONE) {
-      ValuesToPostScript(ps, elemPtr, penPtr, elemPtr->activePts.length,
-			 elemPtr->activePts.points, elemPtr->activePts.map);
+    if (penOps->valueShow != SHOW_NONE) {
+      ValuesToPostScript(ps, lePtr, penPtr, lePtr->activePts.length,
+			 lePtr->activePts.points, lePtr->activePts.map);
     }
   }
-  else if (elemPtr->nActiveIndices < 0) {
-    if (penPtr->traceWidth > 0) {
-      if (elemPtr->lines.length > 0) {
+  else if (lePtr->nActiveIndices < 0) {
+    if (penOps->traceWidth > 0) {
+      if (lePtr->lines.length > 0) {
 	SetLineAttributes(ps, penPtr);
-	Blt_Ps_Draw2DSegments(ps, elemPtr->lines.segments, 
-			      elemPtr->lines.length);
+	Blt_Ps_Draw2DSegments(ps, lePtr->lines.segments, 
+			      lePtr->lines.length);
       }
-      if (Blt_Chain_GetLength(elemPtr->traces) > 0) {
-	TracesToPostScript(ps, elemPtr, (LinePen *)penPtr);
+      if (Blt_Chain_GetLength(lePtr->traces) > 0) {
+	TracesToPostScript(ps, lePtr, (LinePen *)penPtr);
       }
     }
-    if (penPtr->symbol.type != SYMBOL_NONE) {
+    if (penOps->symbol.type != SYMBOL_NONE) {
       SymbolsToPostScript(graphPtr, ps, penPtr, symbolSize,
-			  elemPtr->symbolPts.length, elemPtr->symbolPts.points);
+			  lePtr->symbolPts.length, lePtr->symbolPts.points);
     }
-    if (penPtr->valueShow != SHOW_NONE) {
-      ValuesToPostScript(ps, elemPtr, penPtr, elemPtr->symbolPts.length, 
-			 elemPtr->symbolPts.points, elemPtr->symbolPts.map);
+    if (penOps->valueShow != SHOW_NONE) {
+      ValuesToPostScript(ps, lePtr, penPtr, lePtr->symbolPts.length, 
+			 lePtr->symbolPts.points, lePtr->symbolPts.map);
     }
   }
 }
 
 static void NormalLineToPostScriptProc(Graph* graphPtr, Blt_Ps ps, 
-				       Element *basePtr)
+				       Element *elemPtr)
 {
-  LineElement* elemPtr = (LineElement *)basePtr;
-  Blt_ChainLink link;
-  unsigned int count;
+  LineElement* lePtr = (LineElement *)elemPtr;
+  LineElementOptions* ops = (LineElementOptions*)lePtr->ops;
 
-  /* Draw fill area */
-  if (elemPtr->fillPts) {
-    /* Create a path to use for both the polygon and its outline. */
+  // Draw fill area
+  if (lePtr->fillPts) {
+    // Create a path to use for both the polygon and its outline
     Blt_Ps_Append(ps, "% start fill area\n");
-    Blt_Ps_Polyline(ps, elemPtr->fillPts, elemPtr->nFillPts);
+    Blt_Ps_Polyline(ps, lePtr->fillPts, lePtr->nFillPts);
 
-    /* If the background fill color was specified, draw the polygon in a
-     * solid fashion with that color.  */
-    if (elemPtr->fillBgColor) {
-      Blt_Ps_XSetBackground(ps, elemPtr->fillBgColor);
+    // If the background fill color was specified, draw the polygon in a
+    // solid fashion with that color
+    if (lePtr->fillBgColor) {
+      Blt_Ps_XSetBackground(ps, lePtr->fillBgColor);
       Blt_Ps_Append(ps, "gsave fill grestore\n");
     }
-    Blt_Ps_XSetForeground(ps, elemPtr->fillFgColor);
-    if (elemPtr->fillBg) {
+    Blt_Ps_XSetForeground(ps, ops->fillFgColor);
+    if (ops->fillBg)
       Blt_Ps_Append(ps, "gsave fill grestore\n");
-      /* TBA: Transparent tiling is the hard part. */
-    } else {
+    else
       Blt_Ps_Append(ps, "gsave fill grestore\n");
-    }
+
     Blt_Ps_Append(ps, "% end fill area\n");
   }
 
-  /* Draw lines (strip chart) or traces (xy graph) */
-  if (elemPtr->lines.length > 0) {
-    for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link; 
+  // Draw lines (strip chart) or traces (xy graph)
+  if (lePtr->lines.length > 0) {
+    for (Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette); link; 
 	 link = Blt_Chain_NextLink(link)) {
       LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
       LinePen* penPtr = (LinePen *)stylePtr->penPtr;
-      if ((stylePtr->lines.length > 0) && (penPtr->traceWidth > 0)) {
+      LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
+      if ((stylePtr->lines.length > 0) && (penOps->traceWidth > 0)) {
 	SetLineAttributes(ps, penPtr);
 	Blt_Ps_Append(ps, "% start segments\n");
 	Blt_Ps_Draw2DSegments(ps, stylePtr->lines.segments, 
@@ -2935,47 +2992,50 @@ static void NormalLineToPostScriptProc(Graph* graphPtr, Blt_Ps ps,
     }
   }
   else {
-    LinePen* penPtr = NORMALPEN(elemPtr);
-    if ((Blt_Chain_GetLength(elemPtr->traces) > 0) && 
-	(penPtr->traceWidth > 0)) {
-      TracesToPostScript(ps, elemPtr, penPtr);
+    LinePen* penPtr = NORMALPEN(ops);
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+
+    if ((Blt_Chain_GetLength(lePtr->traces) > 0) && 
+	(penOps->traceWidth > 0)) {
+      TracesToPostScript(ps, lePtr, penPtr);
     }
   }
 
-  /* Draw symbols, error bars, values. */
+  // Draw symbols, error bars, values
 
-  count = 0;
-  for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link;
+  unsigned int count =0;
+  for (Blt_ChainLink link = Blt_Chain_FirstLink(ops->stylePalette); link;
        link = Blt_Chain_NextLink(link)) {
 
     LineStyle *stylePtr = (LineStyle*)Blt_Chain_GetValue(link);
     LinePen* penPtr = (LinePen *)stylePtr->penPtr;
-    XColor* colorPtr = penPtr->errorBarColor;
+    LinePenOptions* penOps = (LinePenOptions*)penPtr->ops;
+    XColor* colorPtr = penOps->errorBarColor;
     if (!colorPtr)
-      colorPtr = penPtr->traceColor;
+      colorPtr = penOps->traceColor;
 
-    if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) {
-      Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, 
+    if ((stylePtr->xeb.length > 0) && (penOps->errorBarShow & SHOW_X)) {
+      Blt_Ps_XSetLineAttributes(ps, colorPtr, penOps->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, 
+    if ((stylePtr->yeb.length > 0) && (penOps->errorBarShow & SHOW_Y)) {
+      Blt_Ps_XSetLineAttributes(ps, colorPtr, penOps->errorBarLineWidth, 
 				NULL, CapButt, JoinMiter);
       Blt_Ps_Draw2DSegments(ps, stylePtr->yeb.segments,
 			    stylePtr->yeb.length);
     }
     if ((stylePtr->symbolPts.length > 0) &&
-	(penPtr->symbol.type != SYMBOL_NONE)) {
+	(penOps->symbol.type != SYMBOL_NONE)) {
       SymbolsToPostScript(graphPtr, ps, penPtr, stylePtr->symbolSize, 
 			  stylePtr->symbolPts.length, 
 			  stylePtr->symbolPts.points);
     }
-    if (penPtr->valueShow != SHOW_NONE) {
-      ValuesToPostScript(ps, elemPtr, penPtr, stylePtr->symbolPts.length, 
+    if (penOps->valueShow != SHOW_NONE) {
+      ValuesToPostScript(ps, lePtr, penPtr, stylePtr->symbolPts.length, 
 			 stylePtr->symbolPts.points, 
-			 elemPtr->symbolPts.map + count);
+			 lePtr->symbolPts.map + count);
     }
     count += stylePtr->symbolPts.length;
   }