e70152e44cc66cc599ff6b699eb8adc07f3e656a
kent
  Sat May 24 21:09:34 2014 -0700
Adding Copyright NNNN Regents of the University of California to all files I believe with reasonable certainty were developed under UCSC employ or as part of Genome Browser copyright assignment.
diff --git src/hg/sageVisCGI/gnuPlot2D.c src/hg/sageVisCGI/gnuPlot2D.c
index 2bf6449..ac3d19e 100644
--- src/hg/sageVisCGI/gnuPlot2D.c
+++ src/hg/sageVisCGI/gnuPlot2D.c
@@ -1,1267 +1,1270 @@
 /* gnuPlot2D.c was originally generated by the autoSql program, which also 
  * generated gnuPlot2D.h and gnuPlot2D.sql.  This module links the database and
  * the RAM representation of objects. */
 
+/* Copyright (C) 2005 The Regents of the University of California 
+ * See README in this or parent directory for licensing information. */
+
 #include "common.h"
 #include "linefile.h"
 #include "jksql.h"
 #include "hash.h"
 #include "portable.h"
 #include "gnuPlot2D.h"
 
 
 static char *gptEmptyField = "_NOT_SET_";
 
 void graphPoint2DStaticLoad(char **row, struct graphPoint2D *ret)
 /* Load a row from graphPoint2D table into ret.  The contents of ret will
  * be replaced at the next call to this function. */
 {
 ret->x = atof(row[0]);
 ret->y = atof(row[1]);
 ret->xDelta = atof(row[2]);
 ret->yDelta = atof(row[3]);
 ret->name = row[4];
 ret->hName = row[5];
 ret->groupName = row[6];
 ret->other = row[7];
 }
 
 struct graphPoint2D *graphPoint2DLoad(char **row)
 /* Load a graphPoint2D from row fetched with select * from graphPoint2D
  * from database.  Dispose of this with graphPoint2DFree(). */
 {
 struct graphPoint2D *ret;
 
 AllocVar(ret);
 ret->x = atof(row[0]);
 ret->y = atof(row[1]);
 ret->xDelta = atof(row[2]);
 ret->yDelta = atof(row[3]);
 ret->name = cloneString(row[4]);
 ret->hName = cloneString(row[5]);
 ret->groupName = cloneString(row[6]);
 ret->other = cloneString(row[7]);
 return ret;
 }
 
 struct graphPoint2D *graphPoint2DLoadAll(char *fileName) 
 /* Load all graphPoint2D from a tab-separated file.
  * Dispose of this with graphPoint2DFreeList(). */
 {
 struct graphPoint2D *list = NULL, *el;
 struct lineFile *lf = lineFileOpen(fileName, TRUE);
 char *row[8];
 
 while (lineFileRow(lf, row))
     {
     el = graphPoint2DLoad(row);
     slAddHead(&list, el);
     }
 lineFileClose(&lf);
 slReverse(&list);
 return list;
 }
 
 struct graphPoint2D *graphPoint2DCommaIn(char **pS, struct graphPoint2D *ret)
 /* Create a graphPoint2D out of a comma separated string. 
  * This will fill in ret if non-null, otherwise will
  * return a new graphPoint2D */
 {
 char *s = *pS;
 
 if (ret == NULL)
     AllocVar(ret);
 ret->x = sqlSignedComma(&s);
 ret->y = sqlSignedComma(&s);
 ret->xDelta = sqlSignedComma(&s);
 ret->yDelta = sqlSignedComma(&s);
 ret->name = sqlStringComma(&s);
 ret->hName = sqlStringComma(&s);
 ret->groupName = sqlStringComma(&s);
 ret->other = sqlStringComma(&s);
 *pS = s;
 return ret;
 }
 
 void graphPoint2DFree(struct graphPoint2D **pEl)
 /* Free a single dynamically allocated graphPoint2D such as created
  * with graphPoint2DLoad(). */
 {
 struct graphPoint2D *el;
 
 if ((el = *pEl) == NULL) return;
 freeMem(el->name);
 freeMem(el->hName);
 freeMem(el->groupName);
 freeMem(el->other);
 freez(pEl);
 }
 
 void graphPoint2DFreeList(struct graphPoint2D **pList)
 /* Free a list of dynamically allocated graphPoint2D's */
 {
 struct graphPoint2D *el, *next;
 
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     graphPoint2DFree(&el);
     }
 *pList = NULL;
 }
 
 void graphPoint2DOutput(struct graphPoint2D *el, FILE *f, char sep, char lastSep) 
 /* Print out graphPoint2D.  Separate fields with sep. Follow last field with lastSep. */
 {
 fprintf(f, "%f", el->x);
 fputc(sep,f);
 fprintf(f, "%f", el->y);
 fputc(sep,f);
 fprintf(f, "%f", el->xDelta);
 fputc(sep,f);
 fprintf(f, "%f", el->yDelta);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->name);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->hName);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->groupName);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->other);
 if (sep == ',') fputc('"',f);
 fputc(lastSep,f);
 }
 
 /*
 struct gnuPlot2D *gnuPlot2DLoad(char **row)
 * Load a gnuPlot2D from row fetched with select * from gnuPlot2D
  * from database.  Dispose of this with gnuPlot2DFree(). *
 {
 struct gnuPlot2D *ret;
 int sizeOne,i;
 char *s;
 
 AllocVar(ret);
 ret->numPlots = sqlSigned(row[0]);
 ret->numFiles = sqlSigned(row[1]);
 ret->numFunctions = sqlSigned(row[9]);
 s = row[2];
 for (i=0; i<ret->numPlots; ++i)
     {
     s = sqlEatChar(s, '{');
     slSafeAddHead(&ret->gpList, graphPoint2DCommaIn(&s, NULL));
     s = sqlEatChar(s, '}');
     s = sqlEatChar(s, ',');
     }
 slReverse(&ret->gpList);
 ret->fileName = cloneString(row[3]);
 ret->directory = cloneString(row[4]);
 sqlStringDynamicArray(row[5], &ret->tempFiles, &sizeOne);
 assert(sizeOne == ret->numFiles);
 ret->imageFormat = cloneString(row[6]);
 sqlStringDynamicArray(row[7], &ret->styles, &sizeOne);
 assert(sizeOne == ret->numPlots);
 ret->functions = sqlSigned(row[8]);
 sqlStringDynamicArray(row[10], &ret->functionStyles, &sizeOne);
 assert(sizeOne == ret->numFunctions);
 ret->grid = sqlSigned(row[11]);
 ret->xtics = sqlSigned(row[12]);
 ret->ytics = sqlSigned(row[13]);
 ret->xTicFormat = cloneString(row[14]);
 ret->yTicFormat = cloneString(row[15]);
 ret->xDataLabels = sqlSigned(row[16]);
 ret->yDataLabels = sqlSigned(row[17]);
 ret->xlogAxis = sqlSigned(row[18]);
 ret->ylogAxis = sqlSigned(row[19]);
 ret->yMin = atof(row[20]);
 ret->yMax = atof(row[21]);
 ret->xMin = atof(row[22]);
 ret->xMax = atof(row[23]);
 ret->title = cloneString(row[24]);
 ret->xlabel = cloneString(row[25]);
 ret->ylabel = cloneString(row[26]);
 ret->legend = cloneString(row[27]);
 ret->other = cloneString(row[28]);
 return ret;
 }
 */
 struct gnuPlot2D *gnuPlot2DLoad(char **row)
 /* Load a gnuPlot2D from row fetched with select * from gnuPlot2D
  * from database.  Dispose of this with gnuPlot2DFree(). */
 {
 struct gnuPlot2D *ret;
 int sizeOne,i;
 char *s;
 
 AllocVar(ret);
 ret->numPlots = sqlSigned(row[0]);
 ret->numFiles = sqlSigned(row[1]);
 ret->numFunctions = sqlSigned(row[10]);
 ret->maxPlots = sqlSigned(row[2]);
 ret->maxFunctions = sqlSigned(row[3]);
 s = row[4];
 for (i=0; i<ret->numPlots; ++i)
     {
     s = sqlEatChar(s, '{');
     slSafeAddHead(&ret->gpList, graphPoint2DCommaIn(&s, NULL));
     s = sqlEatChar(s, '}');
     s = sqlEatChar(s, ',');
     }
 slReverse(&ret->gpList);
 ret->fileName = cloneString(row[5]);
 ret->directory = cloneString(row[6]);
 sqlStringDynamicArray(row[7], &ret->tempFiles, &sizeOne);
 assert(sizeOne == ret->numFiles);
 ret->imageFormat = cloneString(row[8]);
 sqlStringDynamicArray(row[9], &ret->styles, &sizeOne);
 assert(sizeOne == ret->numPlots);
 sqlStringDynamicArray(row[11], &ret->functions, &sizeOne);
 assert(sizeOne == ret->numFunctions);
 sqlStringDynamicArray(row[12], &ret->functionStyles, &sizeOne);
 assert(sizeOne == ret->numFunctions);
 ret->grid = sqlSigned(row[13]);
 ret->xtics = sqlSigned(row[14]);
 ret->ytics = sqlSigned(row[15]);
 ret->xTicFormat = cloneString(row[16]);
 ret->yTicFormat = cloneString(row[17]);
 ret->xErrorBars = sqlSigned(row[18]);
 ret->yErrorBars = sqlSigned(row[19]);
 ret->xDataLabels = sqlSigned(row[20]);
 ret->yDataLabels = sqlSigned(row[21]);
 ret->xlogAxis = sqlSigned(row[22]);
 ret->ylogAxis = sqlSigned(row[23]);
 ret->yMin = atof(row[24]);
 ret->yMax = atof(row[25]);
 ret->xMin = atof(row[26]);
 ret->yMax = atof(row[27]);
 ret->title = cloneString(row[28]);
 ret->xlabel = cloneString(row[29]);
 ret->ylabel = cloneString(row[30]);
 ret->legend = cloneString(row[31]);
 ret->other = cloneString(row[32]);
 return ret;
 }
 
 struct gnuPlot2D *gnuPlot2DLoadAll(char *fileName) 
 /* Load all gnuPlot2D from a tab-separated file.
  * Dispose of this with gnuPlot2DFreeList(). */
 {
 struct gnuPlot2D *list = NULL, *el;
 struct lineFile *lf = lineFileOpen(fileName, TRUE);
 char *row[29];
 
 while (lineFileRow(lf, row))
     {
     el = gnuPlot2DLoad(row);
     slAddHead(&list, el);
     }
 lineFileClose(&lf);
 slReverse(&list);
 return list;
 }
 
 struct gnuPlot2D *gnuPlot2DCommaIn(char **pS, struct gnuPlot2D *ret)
 /* Create a gnuPlot2D out of a comma separated string. 
  * This will fill in ret if non-null, otherwise will
  * return a new gnuPlot2D */
 {
 char *s = *pS;
 int i;
 
 if (ret == NULL)
     AllocVar(ret);
 ret->numPlots = sqlSignedComma(&s);
 ret->numFiles = sqlSignedComma(&s);
 ret->maxPlots = sqlSignedComma(&s);
 ret->maxFunctions = sqlSignedComma(&s);
 s = sqlEatChar(s, '{');
 for (i=0; i<ret->numPlots; ++i)
     {
     s = sqlEatChar(s, '{');
     slSafeAddHead(&ret->gpList, graphPoint2DCommaIn(&s,NULL));
     s = sqlEatChar(s, '}');
     s = sqlEatChar(s, ',');
     }
 slReverse(&ret->gpList);
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->fileName = sqlStringComma(&s);
 ret->directory = sqlStringComma(&s);
 s = sqlEatChar(s, '{');
 AllocArray(ret->tempFiles, ret->numFiles);
 for (i=0; i<ret->numFiles; ++i)
     {
     ret->tempFiles[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->imageFormat = sqlStringComma(&s);
 s = sqlEatChar(s, '{');
 AllocArray(ret->styles, ret->numPlots);
 for (i=0; i<ret->numPlots; ++i)
     {
     ret->styles[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->numFunctions = sqlSignedComma(&s);
 s = sqlEatChar(s, '{');
 AllocArray(ret->functions, ret->numFunctions);
 for (i=0; i<ret->numFunctions; ++i)
     {
     ret->functions[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 s = sqlEatChar(s, '{');
 AllocArray(ret->functionStyles, ret->numFunctions);
 for (i=0; i<ret->numFunctions; ++i)
     {
     ret->functionStyles[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->grid = sqlSignedComma(&s);
 ret->xtics = sqlSignedComma(&s);
 ret->ytics = sqlSignedComma(&s);
 ret->xTicFormat = sqlStringComma(&s);
 ret->yTicFormat = sqlStringComma(&s);
 ret->xErrorBars = sqlSignedComma(&s);
 ret->yErrorBars = sqlSignedComma(&s);
 ret->xDataLabels = sqlSignedComma(&s);
 ret->yDataLabels = sqlSignedComma(&s);
 ret->xlogAxis = sqlSignedComma(&s);
 ret->ylogAxis = sqlSignedComma(&s);
 ret->yMin = sqlSignedComma(&s);
 ret->yMax = sqlSignedComma(&s);
 ret->xMin = sqlSignedComma(&s);
 ret->yMax = sqlSignedComma(&s);
 ret->title = sqlStringComma(&s);
 ret->xlabel = sqlStringComma(&s);
 ret->ylabel = sqlStringComma(&s);
 ret->legend = sqlStringComma(&s);
 ret->other = sqlStringComma(&s);
 *pS = s;
 return ret;
 }
 
 #ifdef NOT
 struct gnuPlot2D *gnuPlot2DCommaIn(char **pS, struct gnuPlot2D *ret)
 /* Create a gnuPlot2D out of a comma separated string. 
  * This will fill in ret if non-null, otherwise will
  * return a new gnuPlot2D */
 {
 char *s = *pS;
 int i;
 
 if (ret == NULL)
     AllocVar(ret);
 ret->numPlots = sqlSignedComma(&s);
 ret->numFiles = sqlSignedComma(&s);
 s = sqlEatChar(s, '{');
 for (i=0; i<ret->numPlots; ++i)
     {
     s = sqlEatChar(s, '{');
     slSafeAddHead(&ret->gpList[i], graphPoint2DCommaIn(&s,NULL));
     s = sqlEatChar(s, '}');
     s = sqlEatChar(s, ',');
     }
 slReverse(&ret->gpList);
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->fileName = sqlStringComma(&s);
 ret->directory = sqlStringComma(&s);
 s = sqlEatChar(s, '{');
 AllocArray(ret->tempFiles, ret->numFiles);
 for (i=0; i<ret->numFiles; ++i)
     {
     ret->tempFiles[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->imageFormat = sqlStringComma(&s);
 s = sqlEatChar(s, '{');
 AllocArray(ret->styles, ret->numPlots);
 for (i=0; i<ret->numPlots; ++i)
     {
     ret->styles[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->functions = sqlSignedComma(&s);
 ret->numFunctions = sqlSignedComma(&s);
 s = sqlEatChar(s, '{');
 AllocArray(ret->functionStyles, ret->numFunctions);
 for (i=0; i<ret->numFunctions; ++i)
     {
     ret->functionStyles[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 ret->grid = sqlSignedComma(&s);
 ret->xtics = sqlSignedComma(&s);
 ret->ytics = sqlSignedComma(&s);
 ret->xTicFormat = sqlStringComma(&s);
 ret->yTicFormat = sqlStringComma(&s);
 ret->xDataLabels = sqlSignedComma(&s);
 ret->yDataLabels = sqlSignedComma(&s);
 ret->xlogAxis = sqlSignedComma(&s);
 ret->ylogAxis = sqlSignedComma(&s);
 ret->yMin = sqlSignedComma(&s);
 ret->yMax = sqlSignedComma(&s);
 ret->xMin = sqlSignedComma(&s);
 ret->xMax = sqlSignedComma(&s);
 ret->title = sqlStringComma(&s);
 ret->xlabel = sqlStringComma(&s);
 ret->ylabel = sqlStringComma(&s);
 ret->legend = sqlStringComma(&s);
 ret->other = sqlStringComma(&s);
 *pS = s;
 return ret;
 } 
 #endif	/*	NOT	*/
 
 void gnuPlot2DFree(struct gnuPlot2D **pEl)
 /* Free a single dynamically allocated gnuPlot2D such as created
  * with gnuPlot2DLoad(). */
 {
 struct gnuPlot2D *el;
 int i;
 if ((el = *pEl) == NULL) return;
 for(i=0;i<el->numPlots;i++)
     {
     graphPoint2DFreeList(&el->gpList[i]);
     }
 freeMem(el->fileName);
 freeMem(el->directory);
 /* All strings in tempFiles are allocated at once, so only need to free first. */
 freeMem(el->tempFiles[0]);
 freeMem(el->tempFiles);
 freeMem(el->imageFormat);
 /* All strings in styles are allocated at once, so only need to free first. */
 freeMem(el->styles[0]);
 freeMem(el->styles);
 /* All strings in functionStyles are allocated at once, so only need to free first. */
 freeMem(el->functionStyles[0]);
 freeMem(el->functionStyles);
 freeMem(el->xTicFormat);
 freeMem(el->yTicFormat);
 freeMem(el->title);
 freeMem(el->xlabel);
 freeMem(el->ylabel);
 freeMem(el->legend);
 freeMem(el->other);
 freez(pEl);
 }
 
 void gnuPlot2DFreeList(struct gnuPlot2D **pList)
 /* Free a list of dynamically allocated gnuPlot2D's */
 {
 struct gnuPlot2D *el, *next;
 
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     gnuPlot2DFree(&el);
     }
 *pList = NULL;
 }
 
 void gnuPlot2DOutput(struct gnuPlot2D *el, FILE *f, char sep, char lastSep) 
 /* Print out gnuPlot2D.  Separate fields with sep. Follow last field with lastSep. */
 {
 int i;
 fprintf(f, "%d", el->numPlots);
 fputc(sep,f);
 fprintf(f, "%d", el->numFiles);
 fputc(sep,f);
 fprintf(f, "%d", el->maxPlots);
 fputc(sep,f);
 fprintf(f, "%d", el->maxFunctions);
 fputc(sep,f);
 /* Loading graphPoint2D list. */
 el->gpList = needMem(sizeof(struct graphPoint2D **) *el->maxPlots);
 for(i=0;i<el->numPlots; i++)
     {
     struct graphPoint2D *it = el->gpList[i];
     if (sep == ',') fputc('{',f);
     for (i=0; i<el->numPlots; ++i)
         {
         fputc('{',f);
         graphPoint2DCommaOut(it,f);
         it = it->next;
         fputc('}',f);
         fputc(',',f);
         }
     if (sep == ',') fputc('}',f);
     }
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->fileName);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->directory);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->numFiles; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->tempFiles[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->imageFormat);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->numPlots; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->styles[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 fprintf(f, "%d", el->numFunctions);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->numFunctions; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->functions[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->numFunctions; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->functionStyles[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 fprintf(f, "%d", el->grid);
 fputc(sep,f);
 fprintf(f, "%d", el->xtics);
 fputc(sep,f);
 fprintf(f, "%d", el->ytics);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->xTicFormat);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->yTicFormat);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 fprintf(f, "%d", el->xErrorBars);
 fputc(sep,f);
 fprintf(f, "%d", el->yErrorBars);
 fputc(sep,f);
 fprintf(f, "%d", el->xDataLabels);
 fputc(sep,f);
 fprintf(f, "%d", el->yDataLabels);
 fputc(sep,f);
 fprintf(f, "%d", el->xlogAxis);
 fputc(sep,f);
 fprintf(f, "%d", el->ylogAxis);
 fputc(sep,f);
 fprintf(f, "%f", el->yMin);
 fputc(sep,f);
 fprintf(f, "%f", el->yMax);
 fputc(sep,f);
 fprintf(f, "%f", el->xMin);
 fputc(sep,f);
 fprintf(f, "%f", el->yMax);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->title);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->xlabel);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->ylabel);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->legend);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->other);
 if (sep == ',') fputc('"',f);
 fputc(lastSep,f);
 }
 
 /*
 
 void gnuPlot2DOutput(struct gnuPlot2D *el, FILE *f, char sep, char lastSep) 
 * Print out gnuPlot2D.  Separate fields with sep. Follow last field with lastSep. *
 {
 int i;
 fprintf(f, "%d", el->numPlots, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->numFiles, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->maxPlots, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->maxFunctions, sep);
 fputc(sep,f);
 * Loading graphPoint2D list. *
     {
     for(i=0;i<el->numPlots; i++)
 	{
 	struct graphPoint2D *it = el->gpList[i];
 	if (sep == ',') fputc('{',f);
 	for (; it!=NULL; it=it->next)
 	    {
 	    fputc('{',f);
 	    graphPoint2DCommaOut(it,f);
 	    it = it->next;
 	    fputc('}',f);
 	    fputc(',',f);
 	    }
 	if (sep == ',') fputc('}',f);
 	}
     }
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->fileName, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->directory, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->numFiles; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->tempFiles[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->imageFormat, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->numPlots; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->styles[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 for (i=0; i<el->numFunctions; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->functions[i], sep);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 fputc(sep,f);
 fprintf(f, "%d", el->numFunctions, sep);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->numFunctions; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->functionStyles[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 fprintf(f, "%d", el->grid, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->xtics, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->ytics, sep);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->xTicFormat, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->yTicFormat, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 fprintf(f, "%d", el->xDataLabels, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->yDataLabels, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->xlogAxis, sep);
 fputc(sep,f);
 fprintf(f, "%d", el->ylogAxis, sep);
 fputc(sep,f);
 fprintf(f, "%f", el->yMin, sep);
 fputc(sep,f);
 fprintf(f, "%f", el->yMax, sep);
 fputc(sep,f);
 fprintf(f, "%f", el->xMin, sep);
 fputc(sep,f);
 fprintf(f, "%f", el->xMax, sep);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->title, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->xlabel, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->ylabel, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->legend, sep);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->other, lastSep);
 if (sep == ',') fputc('"',f);
 fputc(lastSep,f);
 } 
 */
 
 
 /*** Handwritten code after this point ***/
 
 /**
  *   Creates a gnuPlot2D struct with default settings,
  * still needs data.
  * @return gnuPlot2D initialized struct
 */
 struct gnuPlot2D *createGnuPlot2D() 
 {
 struct gnuPlot2D *ret;
 int i;
 AllocVar(ret);
 ret->numPlots = 0;
 ret->numFiles = 0;
 ret->maxPlots = 10;
 ret->maxFunctions = 10;
 ret->gpList = needMem(sizeof(struct graphPoint2D **)*ret->maxPlots);
 for(i=0;i<ret->maxPlots;i++)
     ret->gpList[i] = NULL;
 ret->fileName = cloneString("tempPlot.png");
 ret->directory = cloneString("/tmp");
 ret->tempFiles = needMem(sizeof(char **)*ret->maxPlots);
 for(i=0;i<ret->maxPlots;i++)
     ret->tempFiles[i] = cloneString(gptEmptyField);
 ret->imageFormat = cloneString("png color");
 ret->styles = needMem(sizeof(char **)*ret->maxPlots);
 for(i=0;i<ret->maxPlots;i++)
     ret->styles[i] = cloneString(gptEmptyField);
 ret->functions = needMem(sizeof(char **)*ret->maxPlots);
 for(i=0;i<ret->maxFunctions;i++)    
     ret->functions[i] = cloneString(gptEmptyField);
 ret->numFunctions = 0;
 ret->functionStyles = needMem(sizeof(char **)*ret->maxPlots);
 for(i=0;i<ret->maxFunctions;i++)
     ret->functionStyles[i] = cloneString(gptEmptyField);
 ret->grid = 1;
 ret->xtics = 0;
 ret->ytics = 0;
 ret->xTicFormat = cloneString(gptEmptyField);
 ret->yTicFormat = cloneString(gptEmptyField);
 ret->xDataLabels = 0;
 ret->yDataLabels = 0;
 ret->xlogAxis = 0;
 ret->ylogAxis = 0;
 ret->yMin = 0;
 ret->yMax = 0;
 ret->xMin = 0;
 ret->xMax = 0;
 ret->title = cloneString(gptEmptyField);
 ret->xlabel = cloneString(gptEmptyField);
 ret->ylabel = cloneString(gptEmptyField);
 ret->legend = cloneString(gptEmptyField);
 ret->other = cloneString(gptEmptyField);
 return ret;
 }
 
 void checkBufferSize(char **s, int more, int *max, int *size)
 {
 while((*size + more) >= *max)
     {
     ExpandArray(*s,*max, 2*(*max));
     *max = 2*(*max);
     }
 *size = *size + more;
 } 
 
 
 void addCmdString(char **head, char *tail, int *maxBuffSize, int *buffSize) 
 {
 checkBufferSize(head, (strlen(tail)+1), maxBuffSize, buffSize);
 strncat(*head, tail, strlen(tail));
 }
 
 
 void addCmdStrings(char **head, char *tail1, char *tail2, int *maxBuffSize, int *buffSize)
 {
 addCmdString(head,tail1,maxBuffSize,buffSize);
 addCmdString(head,"\"",maxBuffSize,buffSize);
 addCmdString(head,tail2,maxBuffSize,buffSize);
 addCmdString(head,"\"\n",maxBuffSize,buffSize);
 }
 
 
 
 void writeOutHeader(char **cmd, int *maxBuffSize, int *buffSize) 
 {
 char *message = "#This plot was automatically generated by the gnuPlot2D program\n";
 addCmdString(cmd, message,maxBuffSize, buffSize); 
 }
 
 /**
  * Sets the file format for output, i.e. jpeg,png,eps,etc.
  * Example pd->imageFormat = "png"
  */
 void writeOutSetOutput(struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize)
 {
 char *setOutput = "set output ";
 addCmdString(cmd, setOutput, maxBuffSize, buffSize);
 addCmdString(cmd, "\"" , maxBuffSize,buffSize);
 addCmdString(cmd, pd->fileName, maxBuffSize, buffSize);
 addCmdString(cmd, "\"\n", maxBuffSize, buffSize);
 }
 
 /**
  * If the log axis flats are set then writes out the gnuplot
  * command for log axis.
  * @param examines gnuPlot2D->setXLog and gnuPlot2D->setYLog
  */
 void writeOutLogAxis( struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize)
 {
 char *setXLog = "set logscale x\n";
 char *setYLog = "set logscale y\n";
 int additions = 0;
 if(pd->xlogAxis) 
 {
 additions += strlen(setXLog);
 }
 if(pd->ylogAxis)
 {
 additions += strlen(setYLog);
 }
 checkBufferSize(cmd, additions, maxBuffSize, buffSize);
 if(pd->xlogAxis) 
 strncat(*cmd, setXLog, strlen(setXLog));
 if(pd->ylogAxis)
 strncat(*cmd, setYLog, strlen(setYLog));
 }
 
 /**
  * Set the terminal type, i.e. output type: png, jpeg, x11, etc
  * <code><pre> 
  * set terminal {<terminal-type>}
  * </pre></code>
  * @param uses gnuPlot->imageFormat to set, usage gp->imageFormat="jpeg"
  */
 void writeOutTerminal(struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize)
 {
 char *setTerminal = "set term ";
 if(sameWord(pd->imageFormat, gptEmptyField)) 
     return;
 checkBufferSize(cmd, (strlen(setTerminal) + strlen(pd->imageFormat) + 2), maxBuffSize, buffSize);
 strncat(*cmd, setTerminal, strlen(setTerminal));
 strncat(*cmd, pd->imageFormat, strlen(pd->imageFormat));
 strncat(*cmd, "\n", 1);
 }
 
 /**
  * Lays out the axis and other documentations using gnuplot
  * commands.
  *
  * <p><b>Key/Legend:</b>As this command is rather complicated
  * the command is just copied verbatim if gnuPlot2D->title is set.
  * 
  * <code><pre>
  * Keys:
  *   set key {  left | right | top | bottom | outside | below
  *               | <position>}
  *              {Left | Right} {{no}reverse}
  *              {samplen <sample_length>} {spacing <vertical_spacing>}
  *              {width <width_increment>}
  *              {title "<text>"}
  *              {{no}box { {linestyle | ls <line_style>}
  *                         | {linetype | lt <line_type>}
  *                           {linewidth | lw <line_width>}}}
  *   Example:
  *   pt->title = "set key left bottom Left title 'Legend' box 3"
  *</pre></code>
  *<p><b>Labels:</b> Uses the strings supplied for the the gnuplot
  *   label command, same for gnuPlot2D->ylabel and gnuPlot2D->xlabel.
  * <code><pre> 
  *   Labels:
  *   set xlabel {"<label>"} {<xoff>}{,<yoff>} {"<font>{,<size>}"}
  * </pre></code>
  * Example: gp->xlabel = "x axis stuff";
  * <p><b>Title:</b> Uses string supplied in gnuplot2D->title to create
  * gnuplot command to set title:
  * <code><pre>
  *   Title:
  *   set title {"<title-text>"} {<xoff>}{,<yoff>} {"<font>,{<size>}"}
  *  </pre></code>
  *
  * Example: gp->title = "With this plot I conclude my thesis";
  */
 void writeOutInfoLabels(struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize)
 {
 char *setXLabel = "set xlabel ";
 char *setYLabel = "set ylabel ";
 char *setTitle = "set title ";
 
 if(!sameString(pd->xlabel, gptEmptyField)) 
     addCmdStrings(cmd, setXLabel, pd->xlabel, maxBuffSize, buffSize);
 
 if(!sameString(pd->ylabel, gptEmptyField)) 
     addCmdStrings(cmd, setYLabel, pd->ylabel, maxBuffSize, buffSize);
 
 if(!sameString(pd->title, gptEmptyField)) 
     addCmdStrings(cmd, setTitle, pd->title, maxBuffSize, buffSize);
 
 if(!sameString(pd->legend, gptEmptyField)) 
     addCmdString(cmd, pd->legend, maxBuffSize, buffSize);
 
 }
 
 
 
 void addListOfXTicNames(struct graphPoint2D *gp, char **cmd, int *maxBuffSize, int *buffSize)
 {
 char buff[256];
 sprintf(buff, "%g", gp->x);
 addCmdString(cmd, " \"", maxBuffSize, buffSize);
 addCmdString(cmd, gp->name, maxBuffSize, buffSize);
 addCmdString(cmd, "\" ", maxBuffSize, buffSize);
 addCmdString(cmd, buff, maxBuffSize, buffSize);
 }
 
 void addListOfYTicNames(struct graphPoint2D *gp, char **cmd, int *maxBuffSize, int *buffSize)
 {
 char buff[256];
 sprintf(buff, "%g", gp->x);
 addCmdString(cmd, " \"", maxBuffSize, buffSize);
 addCmdString(cmd, gp->name, maxBuffSize, buffSize);
 addCmdString(cmd, "\" ", maxBuffSize, buffSize);
 addCmdString(cmd, buff, maxBuffSize, buffSize);
 }
 
 
 
 /**
  *   Writes out the tick labels for each data point in the data set
  *   if that flag is set. Currently cycles through all of the data
  *   points and puts their name on the axis (rotated on x-axis). The
  *   idea is for use with bar charts etc.
  *   
  *   <code><pre>
  *   Gnuplot documentation:
  *       set xtics {axis | border} {{no}mirror} {{no}rotate}
  *                {  autofreq
  *                 | <incr>
  *                 | <start>, <incr> {,<end>}
  *                 | ({"<label>"} <pos> {,{"<label>"} <pos>}...) }
  *      set noxtics
  *      show xtics
  *   </pre></code>
  */
 void writeOutTicLabels(struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize)
 {
 
 if(pd->xtics) 
     {
     int i;
     char * setXtics = "set xtics rotate (";
     char *end = ")\n";
     addCmdString(cmd, setXtics, maxBuffSize, buffSize);
     for(i=0;i<pd->numPlots;i++) 
 	{
 	addListOfXTicNames(pd->gpList[i], cmd, maxBuffSize, buffSize);
 	if((i+1) < pd->numPlots) 
 	    {
 	    addCmdString(cmd,",", maxBuffSize, buffSize);
 	    }
 	}
     addCmdString(cmd, end, maxBuffSize, buffSize);
     }
 if(pd->ytics)
     {
     int i;
     char * setYtics = "set ytics (";
     char *end = ")\n";
     addCmdString(cmd, setYtics, maxBuffSize, buffSize);
     for(i=0; i<pd->numPlots; i++) 
 	{
 	addListOfYTicNames(pd->gpList[i], cmd, maxBuffSize, buffSize);
 	if((i+1) < pd->numPlots) 
 	    {
 	    addCmdString(cmd,",", maxBuffSize, buffSize);
 	    }
 	}
     addCmdString(cmd, end, maxBuffSize, buffSize);
     }
 }
 
 /**
  * This just puts whatever you have in the other char* into the
  * gnuplot description, The function doesn't even add a newline. This
  * is sort of a power user capability for hacks not currently supported.  
 */
 void writeOutOther(struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize) 
 {
 if(differentString(pd->other, gptEmptyField))
     {
     addCmdString(cmd, pd->other,maxBuffSize, buffSize); 
     }
 }
 
 void setMinMax(float min, float max,char **cmd,int *maxBuffSize,int *buffSize)
 {
 char buff[256];
 sprintf(buff, "[%g:%g] ", min, max);
 addCmdString(cmd, buff, maxBuffSize, buffSize);
 }
 
 /**
  * Write out plots. This is by far the most complicated outputing
  * part as each bit includes not only data file names but also the 
  * styes, as well as all of the functions. The plot command is 
  * laid out using the gnuplot syntax:
  *
  * <p><code><pre>
  * Gnuplot Documentation:
  *  plot {<ranges>}
  *          {<function> | {"<datafile>" {datafile-modifiers}}}
  *          {axes <axes>} {<title-spec>} {with <style>}
  *           {, {definitions,} <function> ...}
  *
  *  Examples:
  *    plot sin(x)
  *    plot f(x) = sin(x*a), a = .2, f(x), a = .4, f(x)
  *    plot [t=1:10] [-pi:pi*2] tan(t), \
  *           "data.1" using (tan($2)):($3/$4) smooth csplines \
  *            axes x1y2 notitle with lines 5
  *
  * </pre></code>
  * Varables examined/used:
  * <ol>
  * <li>gp->tempFiles;</li> 
  * <li>gp->numPlots;</li>
  * <li>gp->numFiles;</li>
  * <li>gp->functions;</li>
  * <li>gp->functionStyles;</li>
  * <li>gp->numFunctions;</li>
  * <li>gp->styles;</li>
  * </ol>
  * 
  * <p>stles has some of the more interesting possiblities, an example is:
  * <p><code>gp->styles[0] = "linespoints lt 1 lw 2  pt 3 ps 2" where
  * lt = lineType, lw = lineWidth, pt = point type, ps = point size.
  */
 void writeOutPlot(struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize)
 {
 int i,j;
 addCmdString(cmd, "plot " ,maxBuffSize, buffSize); 
 if(pd->xMin != 0 || pd->xMax != 0) 
     setMinMax(pd->xMin, pd->xMax,cmd,maxBuffSize,buffSize);
 if(pd->yMin != 0 || pd->yMax != 0) 
     setMinMax(pd->yMin, pd->yMax,cmd,maxBuffSize,buffSize);
 for(i=0;i<pd->numPlots;i++) 
     {
     if(i!=0)
 	addCmdString(cmd, ",\"" ,maxBuffSize, buffSize); 
     else 
 	addCmdString(cmd, "\"" ,maxBuffSize, buffSize); 
     
     addCmdString(cmd, pd->tempFiles[i], maxBuffSize, buffSize);
     addCmdString(cmd, "\" ", maxBuffSize, buffSize);
     if(pd->gpList[i]->groupName != NULL) 
 	{
 	addCmdString(cmd, " title \"", maxBuffSize, buffSize);
 	addCmdString(cmd, pd->gpList[i]->groupName, maxBuffSize, buffSize);
 	addCmdString(cmd, "\" ", maxBuffSize, buffSize);
 	}
     if(differentString(pd->styles[i],gptEmptyField)) 
 	{
 	addCmdString(cmd, " with ", maxBuffSize, buffSize);
 	addCmdString(cmd, pd->styles[i], maxBuffSize, buffSize);
 	}
     if((i+1) <= pd->numPlots || pd->numFunctions > 0) 
 	addCmdString(cmd, "\t\\\n", maxBuffSize, buffSize);
     else 
 	addCmdString(cmd, "\n", maxBuffSize, buffSize);
     }
 for(j=0;j<pd->numFunctions;j++)
     {
     if(i!=0)
 	addCmdString(cmd, "," ,maxBuffSize, buffSize); 
     addCmdString(cmd, pd->functions[j], maxBuffSize, buffSize);
     if(differentString(pd->functionStyles[j],gptEmptyField)) 
 	{
 	addCmdString(cmd, " with ", maxBuffSize, buffSize);
 	addCmdString(cmd, pd->functionStyles[j], maxBuffSize, buffSize);
 	
 	}
     if((j+1) >= pd->numFunctions) 
 	addCmdString(cmd, "\n", maxBuffSize, buffSize);
     else 
 	addCmdString(cmd, "\t\\\n", maxBuffSize, buffSize);
     }
 addCmdString(cmd, "\n", maxBuffSize, buffSize);
 }
 
 void writeOutGrid(struct gnuPlot2D *pd, char **cmd, int *maxBuffSize, int *buffSize)
 {
 addCmdString(cmd, "set grid\n", maxBuffSize, buffSize);
 }
 
 void writeOutData(struct gnuPlot2D *pd, 
 		  struct graphPoint2D *gp,
 		  char *fileName) 
 {
 FILE *out = mustOpen(fileName, "w");
 struct graphPoint2D *g;
 for(g=gp ; g != NULL; g = g->next) 
     {
     fprintf(out, "%g\t%g", g->x, g->y);
     if(pd->xErrorBars) 
 	fprintf(out, "\t%g", g->xDelta);
     if(pd->yErrorBars)
 	fprintf(out, "\t%g", g->yDelta);
     fprintf(out,"\n");
     }
 carefulClose(&out);
 }
 
 /**
  *   gptGenerateCmd - takes a gnuPlot2D struct and generates a string
  *  containg output to generate plot in gnuplot according to the
  *  information contained. Will errAbort if problems are
  *  encountered. On sucess returns the absolute pathname of the plot or
  *  NULL if plot is displayed in xwindow.  
  *  @param struct gnuPlot2D -contains data to plot 
  *  @return char *cmd - sequence of instructions to create desired plot
  *  remember to free this.
  */
 char *gptGenerateCmd(struct gnuPlot2D *pd)
 {
 int maxBuffSize = 1024, buffSize = 0;
 char *cmd = needMem(sizeof(char) * maxBuffSize);
 int i;
 /* first generate our data files */
 for(i=0; i<pd->numPlots; i++) 
     {
     struct tempName tmpFile;
     makeTempName(&tmpFile, "gnuPlot2D_", ".dat");
 //    sprintf(fileBuffer, "%s/%s",pd->directory,tmpFile);
     ExpandArray(pd->tempFiles,pd->numFiles,(pd->numFiles+1));
     pd->tempFiles[pd->numFiles] = cloneString(tmpFile.forCgi);
     //  writeOutData(pd, pd->gpList[i],fileBuffer);
     writeOutData(pd, pd->gpList[i],tmpFile.forCgi);
     pd->numFiles++;
     }
 
 writeOutHeader(&cmd, &maxBuffSize, &buffSize);
 writeOutSetOutput(pd, &cmd, &maxBuffSize, &buffSize);
 /* Now write out our different parameters */
 writeOutLogAxis(pd, &cmd, &maxBuffSize, &buffSize);
 
 writeOutTerminal(pd, &cmd, &maxBuffSize, &buffSize);
 writeOutGrid(pd, &cmd, &maxBuffSize, &buffSize);
 writeOutInfoLabels(pd, &cmd, &maxBuffSize, &buffSize);
 writeOutTicLabels(pd, &cmd, &maxBuffSize, &buffSize);
 writeOutOther(pd, &cmd, &maxBuffSize, &buffSize);
 writeOutPlot(pd, &cmd, &maxBuffSize, &buffSize);
 return cmd;
 
 }
 
 /**
  * gptPlotFromCmd - this function takes a string generated from gptGenerateCmd() 
  * and generates the actual plot described by it.
  * @param string - cmd, a string containing the commands necessary to
  * generated a gnuplot. Basically a memory version of the batch file
  * which could be used to generate gnuplot from command line
  */
 void gptPlotFromCmd(char *cmd)
 {
 gnuplot_ctrl *gpc = gnuplot_init();
 gnuplot_cmd(gpc, cmd);
 gnuplot_close(gpc);
 }
 
 void gptQuickPlotXY(char *title, char *fileName, 
 		    char *fileFormat, double *x, double *y, int numPoints)
 {
 gnuplot_ctrl *gpc = gnuplot_init();
 
 gnuplot_cmd(gpc, "set term %s", fileFormat);
 if(differentString(fileFormat,"x11"))
     gnuplot_cmd(gpc, "set ouput \"%s\"",fileName);
 gnuplot_plot_xy(gpc, x,y,numPoints,title);
 gnuplot_close(gpc);
 }
 
 void gptAddGraphPointList(struct gnuPlot2D *gPlot, 
 			  struct graphPoint2D *gpList,
 			  char *newStyle)
 {
 char *finalStyle = NULL;
 if(gpList == NULL)
     return;
 if (newStyle == NULL) 
     finalStyle = cloneString("linespoints");
 else 
     finalStyle = cloneString(newStyle);
 if(gPlot->numPlots+1 >= gPlot->maxPlots) 
     {
     ExpandArray(gPlot->gpList, gPlot->maxPlots, (gPlot->maxPlots*2));
     ExpandArray(gPlot->styles, gPlot->maxPlots, (gPlot->maxPlots*2));
     gPlot->maxPlots *= 2;
     }
 gPlot->gpList[gPlot->numPlots] = gpList;
 gPlot->styles[gPlot->numPlots] = finalStyle;
 gPlot->numPlots++;
 }
 
 /**
  * gptRemoveTempFiles - removes temp files created. 
  */
 void gptRemoveTempFiles(struct gnuPlot2D *gPlot)
 {
 int i;
 for(i=0; i<gPlot->numFiles; i++)
     {
     remove(gPlot->tempFiles[i]);
     }
 }