/*----------------------------------------------------------------------------
                       graph.cc (graph object definition)
                       This file is a part of topaz systems
                  Copyright: Hisao Kawaura, All rights reserved
                                   1997 - 99


    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

----------------------------------------------------------------------------*/

#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <unistd.h>
#include "graph.h"
#include "frame.h"
#include "data.h"
#include "vect.h"
#include "vectdefs.h"
#include "col.h"
#include "styledisp.h"
#include "browse.h"
#include "gdi.h"
#include "filepoint.h"
#include "linearfit.h"
#include "system.h"
#include "convtxt.h"
#include "regexpress.h"
#include "paths.h"

extern FileHandleArray *fhvuff;
extern void message(const char *msg);

FILE *fout, *fview;
extern char confpath[1000];
extern char tmppath[1000];
extern char *toshortfilename(char *in);
extern char pid[100];
extern bool isabort();
extern void resetabort();
extern void showsepwin();
extern bool genxdata(double start, double end, int div, int scaling, earray* outx, earray* outy);

graph :: graph() : plobj()
{

  farray = new framearray;
  farray->add(new frame);
  (*farray)[farray->getarraylength() - 1].parent = (void *)this;
  setframeid(farray->getarraylength() - 1);

  gbuffer = new globalbuff;
  init = new globalbuff;

  // this is the topaz version 
  // ex. version 1.23.beta1 = 12301
  version = 34199;

  mag = 1.0;
  autoscalemargin = 10;
  currentframe = 0;
  strcpy(graphname, "untitled.tpz");
  offset.x = 0;
  offset.y = 0;
  papersize.x = 11905;
  papersize.y = 16440;
  updated = false;

  fout = 0;
  fout = fview;
}

graph :: ~graph()
{
  delete farray;
  delete gbuffer;
  delete init;
}

bool graph::get(std::string* member, tokenbuff* outvalue)
{
  std::string out, shrunk;
  int iid;
  char stemp[1024];

  if (topobject(member, &out, &iid) == true)
    {
      if (out == std::string("frame"))
	{
	  if (shrinkobject(member, &shrunk))
	    {
	      if (iid < farray->getarraylength() && iid >= 0)
		{
		  if ((*farray)[iid].get(&shrunk, outvalue))
		    return true;
		  else
		    return false;
		}
	      else if (iid == -2)
		{
		  if ((*farray)[currentframe].get(&shrunk, outvalue))
		    return true;
		  else
		    return false;
		}
	      // first selected
	      else if (iid == -5)
		{
		  for (int i = 0; i < farray->getarraylength(); i++)
		    {
		      if ((*farray)[i].selected)
			{
			  if ((*farray)[i].get(&shrunk, outvalue))
			    return true;
			  else
			    return false;
			}
		    }
		  outvalue->value->add("");
		  return false;
		}
	      else
		return false;
	    }
	  else
	    return false;
	}
      else if (out == std::string("version") && iid == -1)
	{
	  versionstring(stemp);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("versionnumber") && iid == -1)
	{
	  sprintf(stemp, "%d", version);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("mag") && iid == -1)
	{
	  sprintf(stemp, "%.15g", mag);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("graphname") && iid == -1)
	{
	  sprintf(stemp, "%s", graphname);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("offset_x") && iid == -1)
	{
	  sprintf(stemp, "%d", offset.x);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("offset_y") && iid == -1)
	{
	  sprintf(stemp, "%d", offset.y);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("papersize_x") && iid == -1)
	{
	  sprintf(stemp, "%d", papersize.x);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("papersize_y") && iid == -1)
	{
	  sprintf(stemp, "%d", papersize.y);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("autoscalemargin") && iid == -1)
	{
	  sprintf(stemp, "%d", autoscalemargin);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("currentframe") && iid == -1)
	{
	  sprintf(stemp, "%d", currentframe);
	  outvalue->value->add(stemp);
	  return true;
	}
      else if (out == std::string("updated") && iid == -1)
	{
	  sprintf(stemp, "%d", updated);
	  outvalue->value->add(stemp);
	  return true;
	}
      else
	return false;
    }
  else
    return false;
      
  return true;
}

bool graph::set(std::string* member, std::string* setvalue)
{
  std::string out, shrunk;
  int iid;

  if (topobject(member, &out, &iid) == true)
    {
      if (out == std::string("frame"))
	{
	  if (shrinkobject(member, &shrunk))
	    {
	      if (iid < farray->getarraylength() && iid >= 0)
		{
		  if ((*farray)[iid].set(&shrunk, setvalue))
		    {
		      updated = true;
		      return true;
		    }
		  else
		    return false;
		}
	      // current
	      else if (iid == -2)
		{
		  if ((*farray)[currentframe].set(&shrunk, setvalue))
		    {
		      updated = true;
		      return true;
		    }
		  else
		    return false;
		}
	      // selected
	      else if (iid == -3)
		{
		  for (int i = 0; i < farray->getarraylength(); i++)
		    {
		      if ((*farray)[i].selected)
			{
			  if (!(*farray)[i].set(&shrunk, setvalue))
			    return false;
			}
		    }
		  updated = true;
		  return true;
		}
	      // all
	      else if (iid == -4)
		{
		  for (int i = 0; i < farray->getarraylength(); i++)
		    {
		      if (!(*farray)[i].set(&shrunk, setvalue))
			return false;
		    }
		  updated = true;
		  return true;
		}
	      else
		return false;
	    }
	  else
	    return false;
	}
      else if (out == std::string("mag") && iid == -1)
	{
	  mag = atof(setvalue->c_str());
	  return true;
	}
      else if (out == std::string("graphname") && iid == -1)
	{
	  strncpy(graphname,setvalue->c_str(), 1024);
	  return true;
	}
      else if (out == std::string("offset_x") && iid == -1)
	{
	  offset.x = atoi(setvalue->c_str());
	  return true;
	}
      else if (out == std::string("offset_y") && iid == -1)
	{
	  offset.y = atoi(setvalue->c_str());
	  return true;
	}
      else if (out == std::string("papersize_x") && iid == -1)
	{
	  papersize.x = atoi(setvalue->c_str());
	  return true;
	}
      else if (out == std::string("papersize_y") && iid == -1)
	{
	  papersize.y = atoi(setvalue->c_str());
	  return true;
	}
      else if (out == std::string("autoscalemargin") && iid == -1)
	{
	  autoscalemargin = atoi(setvalue->c_str());
	  return true;
	}
      else if (out == std::string("currentframe") && iid == -1)
	{
	  if ( atoi(setvalue->c_str()) < farray->getarraylength() && atoi(setvalue->c_str()) >= 0)
	    currentframe = atoi(setvalue->c_str());
	  else
	    return false;
	  return true;
	}
      else if (out == std::string("updated") && iid == -1)
	{
	  updated = atoi(setvalue->c_str());
	  return true;
	}
      else
	return false;
    }
  else
    return false;
      
  return true;
}


bool gra_paintall(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1, str3;
  int itemp;
  FILE *fp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
	{
	  resetabort();
	  pbegin(true, fp);
	  pclearviewer(true, fp);
	  
	  // execute child objects
	  //frame
	  for (int i = 0; i < gra->farray->getarraylength(); i++)
	    {
	      str3 = std::string("paint");
	      if (!(*gra->farray)[i].exec(&str3, argument, outvalue))
		return false;
	    }
	  
	  ppaint(true, fp);
	  pflush(true, fp);
	  
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_paint(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  FILE *fp;
  std::string str1, str3;
  int itemp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
	{
	  // execute child objects
	  //frame
	  for (int i = 0; i < gra->farray->getarraylength(); i++)
	    {
	      str3 = std::string("paint");
	      if (!(*gra->farray)[i].exec(&str3, argument, outvalue))
		return false;
	    }
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_preout(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;
  FILE *fp;
  int itemp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
	{
	  resetabort();
	  pbegin(true, fp);
	  pclearviewer(true, fp);
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_postout(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;
  FILE *fp;
  int itemp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
	{
	  ppaint(true, fp);
	  pflush(true, fp);
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_drawpaper(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;
  FILE *fp;
  int itemp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
	{
	  gra->drawpaper(true, fp);
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_setbbox(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str3;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1 && (*argument)[0] == std::string("null"))
    {
      // reset bbox
      pbegin(false, 0);
      // calc bbox
      for (int i = 0; i < gra->farray->getarraylength(); i++)
	{
	  str3 = std::string("setbbox");
	  if (!(*gra->farray)[i].exec(&str3, argument, outvalue))
	    return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_gropen(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  FILE *fp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if ((fp = fopen((*argument)[0].c_str(), "r")) != 0)
	{
	  gra->readgraph(fp);
	  fclose (fp);
	  showsepwin();
	  gra->updated = false;
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_grappend(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  FILE *fp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if ((fp = fopen((*argument)[0].c_str(), "r")) != 0)
	{
	  gra->appendgraph(fp);
	  fclose (fp);
	  gra->updated = true;
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_grsave(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  FILE *fp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if ((fp = fopen((*argument)[0].c_str(), "w")) != 0)
	{
	  strcpy(gra->graphname, (*argument)[0].c_str());
	  gra->writegraph(fp);
	  fclose (fp);
	  gra->updated = false;
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_getindex(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  char stemp[100];

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 2 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  for (int i = 0; i < gra->farray->getarraylength(); i++)
	    {
	      if (atoi((*argument)[1].c_str()) == (*gra->farray)[i].id)
		{
		  sprintf(stemp, "%d", i);
		  outvalue->value->add(stemp);
		  return true;
		}
	    }
	  return false;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_delete(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 2 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  gra->updated = true;
	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength() 
	      && 0 <= atoi((*argument)[1].c_str()))
	    gra->farray->remove(atoi((*argument)[1].c_str()));
	  //selected
	  else if (atoi((*argument)[1].c_str()) == -3)
	    {
	      for (int i = gra->farray->getarraylength() - 1; i >= 0; i--)
		if ((*gra->farray)[i].selected)
		  gra->farray->remove(i);
	    }
	  //all
	  else if (atoi((*argument)[1].c_str()) == -4)
	    {
	      for (int i = gra->farray->getarraylength() - 1; i >= 0; i--)
		gra->farray->remove(i);
	    }
	  else
	    return false;
	  
	  if (gra->currentframe > gra->farray->getarraylength() - 1)
	    gra->currentframe = 0;
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_new(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  char stemp[100];

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  gra->updated = true;
	  gra->farray->add(new frame);
	  (*gra->farray)[gra->farray->getarraylength() - 1].parent = (void *)gra;
	  gra->setframeid(gra->farray->getarraylength() - 1);
	  sprintf(stemp, "%d", gra->farray->getarraylength());  
	  outvalue->value->add(stemp);
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_flushselect(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  for (int i = 0; i < gra->farray->getarraylength(); i++)
	    (*gra->farray)[i].selected = false;
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_length(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  char stemp[100];

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  sprintf(stemp, "%d", gra->farray->getarraylength());
	  outvalue->value->add(stemp);
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_top(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 2 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  gra->updated = true;
	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength() 
	      && 0 <= atoi((*argument)[1].c_str()))
	    {
	      gra->farray->top(atoi((*argument)[1].c_str()));
	      return true;
	    }
	  //first selected
	  else if (atoi((*argument)[1].c_str()) == -5)
	    {
	      for (int i = 0; i < gra->farray->getarraylength(); i++)
		{
		  if ((*gra->farray)[i].selected)
		    {
		      gra->farray->top(i);
		      return true;
		    }
		}
	      return true;
	    }
	  else
	    return false;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_up(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 2 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  gra->updated = true;
	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength() 
	      && 0 <= atoi((*argument)[1].c_str()))
	    {
	      gra->farray->up(atoi((*argument)[1].c_str()));
	      return true;
	    }
	  //first selected
	  else if (atoi((*argument)[1].c_str()) == -5)
	    {
	      for (int i = 0; i < gra->farray->getarraylength(); i++)
		{
		  if ((*gra->farray)[i].selected)
		    {
		      gra->farray->up(i);
		      return true;
		    }
		}
	      return true;
	    }
	  else
	    return false;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_down(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 2 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  gra->updated = true;
	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength() 
	      && 0 <= atoi((*argument)[1].c_str()))
	    {
	      gra->farray->down(atoi((*argument)[1].c_str()));
	      return true;
	    }
	  //first selected
	  else if (atoi((*argument)[1].c_str()) == -5)
	    {
	      for (int i = 0; i < gra->farray->getarraylength(); i++)
		{
		  if ((*gra->farray)[i].selected)
		    {
		      gra->farray->down(i);
		      return true;
		    }
		}
	      return true;
	    }
	  else
	    return false;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_bottom(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 2 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  gra->updated = true;
	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength() 
	      && 0 <= atoi((*argument)[1].c_str()))
	    {
	      gra->farray->bottom(atoi((*argument)[1].c_str()));
	      return true;
	    }
	  //first selected
	  else if (atoi((*argument)[1].c_str()) == -5)
	    {
	      for (int i = 0; i < gra->farray->getarraylength(); i++)
		{
		  if ((*gra->farray)[i].selected)
		    {
		      gra->farray->bottom(i);
		      return true;
		    }
		}
	      return true;
	    }
	  else
	    return false;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_copy(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1, str2;
  int itemp1, itemp2;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 3 && iid == -1)
    {
      gra->updated = true;
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  itemp1 = atoi((*argument)[1].c_str());
	  itemp2 = atoi((*argument)[2].c_str());
	  
	  if (itemp1 < gra->farray->getarraylength() 
	      && 0 <= itemp1
	      && itemp2 < gra->farray->getarraylength() 
	      && 0 <= itemp2)
	    {
	      (*gra->farray)[itemp1] = (*gra->farray)[itemp2];
	      
	      for (int j = 0; j < (*gra->farray)[itemp2].darray->getarraylength(); j++)
		{
		  (*(*gra->farray)[itemp1].darray)[j].gettmpdataname(&str1);
		  str1 = std::string(tmppath) + std::string("/") + str1;
		  (*(*gra->farray)[itemp2].darray)[j].gettmpdataname(&str2);
		  str2 = std::string(tmppath) + std::string("/") + str2;
		  if (isfileexist((char *)str2.c_str()) 
		      && !(*(*gra->farray)[itemp2].darray)[j].virgin 
		      && (*gra->farray)[itemp2].withdata)
		    filecp((char *)str1.c_str(), (char *)str2.c_str());
		}
	      
	      return true;
	    }
	  //first selected
	  else if (itemp1 == -5
		   && itemp2 < gra->farray->getarraylength() 
		   && 0 <= itemp2)
	    {
	      for (int i = 0; i < gra->farray->getarraylength(); i++)
		{
		  if ((*gra->farray)[i].selected)
		    {
		      (*gra->farray)[i] = (*gra->farray)[itemp2];
		      
		      for (int j = 0; j < (*gra->farray)[itemp2].darray->getarraylength(); j++)
			{
			  (*(*gra->farray)[i].darray)[j].gettmpdataname(&str1);
			  str1 = std::string(tmppath) + std::string("/") + str1;
			  (*(*gra->farray)[itemp2].darray)[j].gettmpdataname(&str2);
			  str2 = std::string(tmppath) + std::string("/") + str2;
			  if (isfileexist((char *)str2.c_str()) 
			      && !(*(*gra->farray)[itemp2].darray)[j].virgin 
			      && (*gra->farray)[itemp2].withdata)
			    filecp((char *)str1.c_str(), (char *)str2.c_str());
			}
		      
		      return true;
		    }
		}
	      return true;
	    }
	  else if (itemp1 < gra->farray->getarraylength() 
		   && 0 <= itemp1
		   && itemp2  == -5)
	    {
	      for (int i = 0; i < gra->farray->getarraylength(); i++)
		{
		  if ((*gra->farray)[i].selected)
		    {
		      (*gra->farray)[itemp1] = (*gra->farray)[i];
		      
		      for (int j = 0; j < (*gra->farray)[i].darray->getarraylength(); j++)
			{
			  (*(*gra->farray)[itemp1].darray)[j].gettmpdataname(&str1);
			  str1 = std::string(tmppath) + std::string("/") + str1;
			  (*(*gra->farray)[i].darray)[j].gettmpdataname(&str2);
			  str2 = std::string(tmppath) + std::string("/") + str2;
			  if (isfileexist((char *)str2.c_str()) 
			      && !(*(*gra->farray)[i].darray)[j].virgin 
			      && (*gra->farray)[i].withdata)
			    filecp((char *)str1.c_str(), (char *)str2.c_str());
			}
		      
		      return true;
		    }
		}
	      return true;
	    }
	  else
	    return false;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_selectednumber(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  char stemp[100];
  int itemp;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      // frame object
      if ((*argument)[0] == std::string("frame"))
	{
	  itemp = 0;
	  for (int i = 0; i < gra->farray->getarraylength(); i++)
	    {
	      if ((*gra->farray)[i].selected)
		itemp++;
	    }
	  sprintf(stemp, "%d", itemp);
	  outvalue->value->add(stemp);
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_getframetypename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (getframetypename(atoi((*argument)[0].c_str()), &str1))
	{
	  outvalue->value->add(str1.c_str());
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_getlinestylename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (getlinestylename(atoi((*argument)[0].c_str()), &str1))
	{
	  outvalue->value->add(str1.c_str());
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_getlinecapname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case LINECAPBUTT:
	  outvalue->value->add("butt");
	  break;
	case LINECAPROUND:
	  outvalue->value->add("round");
	  break;
	case LINECAPPROJECTING:
	  outvalue->value->add("projecting");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getlinejoinname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case LINEJOINMITER:
	  outvalue->value->add("miter");
	  break;
	case LINEJOINROUND:
	  outvalue->value->add("round");
	  break;
	case LINEJOINBEVEL:
	  outvalue->value->add("bevel");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getinterpolationname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case INTER_POLYLINE:
	  outvalue->value->add("polyline");
	  break;
	case INTER_CLOSEDPOLYLINE:
	  outvalue->value->add("closed polyline");
	  break;
	case INTER_SPLINE:
	  outvalue->value->add("spline");
	  break;
	case INTER_PSPLINE:
	  outvalue->value->add("Pspline");
	  break;
	case INTER_CLOSEDPSPLINE:
	  outvalue->value->add("closed Pspline");
	  break;
	case INTER_BSPLINE:
	  outvalue->value->add("Bspline");
	  break;
	case INTER_CLOSEDBSPLINE:
	  outvalue->value->add("closed Bspline");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getfillstylename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case FILLSTYLESOLID:
	  outvalue->value->add("solid");
	  break;
	case FILLSTYLENULL:
	  outvalue->value->add("null");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getcolorname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;
  unsigned short r, g, b;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 3 && iid == -1) 
    {
      r = (unsigned short)atoi((*argument)[0].c_str());
      g = (unsigned short)atoi((*argument)[1].c_str());
      b = (unsigned short)atoi((*argument)[2].c_str());
      
      getcolorname(r, g, b, &str1);
      outvalue->value->add(str1.c_str());
      return true;
    }
  else
    return false;
}

bool gra_getscalingname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case SCALE_LINEAR:
	  outvalue->value->add("linear");
	  break;
	case SCALE_LOG:
	  outvalue->value->add("log");
	  break;
	case SCALE_INV:
	  outvalue->value->add("inverse");
	  break;
	case SCALE_LOGLINEAR:
	  outvalue->value->add("log (linear)");
	  break;
	case SCALE_INVLINEAR:
	  outvalue->value->add("inverse (linear)");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getcommentlineactionname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case COMMENT_ABORT:
	  outvalue->value->add("abort");
	  break;
	case COMMENT_IGNORE:
	  outvalue->value->add("ignore");
	  break;
	case COMMENT_SEPARTION:
	  outvalue->value->add("separate");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getlabelparityname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case LABELPARITY_PLUS:
	  outvalue->value->add("plus");
	  break;
	case LABELPARITY_MINUS:
	  outvalue->value->add("minus");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getlabelcpparityname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case CROSSPOINTPARITY_CENTER:
	  outvalue->value->add("zero");
	  break;
	case CROSSPOINTPARITY_MINUS:
	  outvalue->value->add("minus");
	  break;
	case CROSSPOINTPARITY_PLUS:
	  outvalue->value->add("plus");
	  break;
	case CROSSPOINTPARITY_NULL:
	  outvalue->value->add("null");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getlabelformatname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case LABEL_FORMAT_NULL:
	  outvalue->value->add("null");
	  break;
	case LABEL_FORMAT_DECIMAL:
	  outvalue->value->add("decimal");
	  break;
	case LABEL_FORMAT_EXP:
	  outvalue->value->add("exp.");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getpartsname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (getpartsname(atoi((*argument)[0].c_str()), &str1))
	{
	  outvalue->value->add(str1.c_str());
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_gettextfacename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (gettextfacename(atoi((*argument)[0].c_str()), &str1))
	{
	  outvalue->value->add(str1.c_str());
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_gettextjpfacename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (gettextjpfacename(atoi((*argument)[0].c_str()), &str1))
	{
	  outvalue->value->add(str1.c_str());
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_getlinearfitfunctionname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{
  std::string str1;

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      if (getlinearfitfunctionname(atoi((*argument)[0].c_str()), &str1))
	{
	  outvalue->value->add(str1.c_str());
	  return true;
	}
      else
	return false;
    }
  else
    return false;
}

bool gra_getdatasearchpathname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case PATH_ABSOLUTE:
	  outvalue->value->add("absolute");
	  break;
	case PATH_RELATIVE:
	  outvalue->value->add("relative");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_getmarkertypename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 1 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case MARKER_NULL:
	  outvalue->value->add("null");
	  break;
	case MARKER_SQUARE:
	  outvalue->value->add("square");
	  break;
	case MARKER_TRIANGLE:
	  outvalue->value->add("triangle");
	  break;
	case MARKER_REVTRIANGLE:
	  outvalue->value->add("rev. triangle");
	  break;
	case MARKER_DIAMOND:
	  outvalue->value->add("diamond");
	  break;
	case MARKER_CIRCLE:
	  outvalue->value->add("circle");
	  break;
	case MARKER_CROSS:
	  outvalue->value->add("cross");
	  break;
	case MARKER_DCROSS:
	  outvalue->value->add("diag. cross");
	  break;
	case MARKER_VAREA:
	  outvalue->value->add("vertical area");
	  break;
	case MARKER_HAREA:
	  outvalue->value->add("horizontal area");
	  break;
	case MARKER_VBAR:
	  outvalue->value->add("vertical bar");
	  break;
	case MARKER_HBAR:
	  outvalue->value->add("horizontal bar");
	  break;
	case MARKER_VSTEP:
	  outvalue->value->add("vertical step");
	  break;
	case MARKER_HSTEP:
	  outvalue->value->add("horizontal step");
	  break;
	case MARKER_VBAR2:
	  outvalue->value->add("vertical bar2");
	  break;
	case MARKER_HBAR2:
	  outvalue->value->add("horizontal bar2");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

bool gra_gettickdirname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
{

  if (gra == 0 || outvalue == 0)
    return false;

  if (arglength == 2 && iid == -1)
    {
      switch(atoi((*argument)[0].c_str()))
	{
	case TICKPARITY_NULL:
	  outvalue->value->add("null");
	  break;
	case TICKPARITY_PLUS:
	  switch(atoi((*argument)[1].c_str()))
	    {
	    case 0:
	    case 3:
	      outvalue->value->add("out");
	      break;
	    case 1:
	    case 2:
	      outvalue->value->add("in");
	      break;
	    default:
	      outvalue->value->add("");
	      break;
	    }
	  break;
	case TICKPARITY_MINUS:
	  switch(atoi((*argument)[1].c_str()))
	    {
	    case 0:
	    case 3:
	      outvalue->value->add("in");
	      break;
	    case 1:
	    case 2:
	      outvalue->value->add("out");
	      break;
	    default:
	      outvalue->value->add("");
	      break;
	    }
	  break;
	case TICKPARITY_BOTH:
	  outvalue->value->add("both");
	  break;
	default:
	  return false;
	}
      return true;
    }
  else
    return false;
}

typedef struct grfuncs
{
  char *function;
  bool (*func)(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue);
}GRFUNCS;

GRFUNCS grf[] = {
  {"paintall", gra_paintall},
  {"paint", gra_paint},
  {"preout", gra_preout},
  {"postout", gra_postout},
  {"drawpaper", gra_drawpaper},
  {"setbbox", gra_setbbox},
  {"gropen", gra_gropen},
  {"grappend", gra_grappend},
  {"grsave", gra_grsave},
  {"getindex", gra_getindex},
  {"delete", gra_delete},
  {"new", gra_new},
  {"flushselect", gra_flushselect},
  {"length", gra_length},
  {"top", gra_top},
  {"up", gra_up},
  {"down", gra_down},
  {"bottom", gra_bottom},
  {"copy", gra_copy},
  {"selectednumber", gra_selectednumber},
  {"getframetypename", gra_getframetypename},
  {"getlinestylename", gra_getlinestylename},
  {"getlinecapname", gra_getlinecapname},
  {"getlinejoinname", gra_getlinejoinname},
  {"getinterpolationname", gra_getinterpolationname},
  {"getfillstylename", gra_getfillstylename},
  {"getcolorname", gra_getcolorname},
  {"getscalingname", gra_getscalingname},
  {"getcommentlineactionname", gra_getcommentlineactionname},
  {"getlabelparityname", gra_getlabelparityname},
  {"getlabelcpparityname", gra_getlabelcpparityname},
  {"getlabelformatname", gra_getlabelformatname},
  {"getpartsname", gra_getpartsname},
  {"gettextfacename", gra_gettextfacename},
  {"gettextjpfacename", gra_gettextjpfacename},
  {"getlinearfitfunctionname", gra_getlinearfitfunctionname},
  {"getdatasearchpathname", gra_getdatasearchpathname},
  {"getmarkertypename", gra_getmarkertypename},
  {"gettickdirname", gra_gettickdirname},
  {0, 0}
}; 

bool graph::exec(std::string* function, buffarray *argument, tokenbuff* outvalue)
{
  std::string out, shrunk, str1, str2, str3;
  int iid, arglength;
  buffarray tempbuffarray;

  GRFUNCS *grfncs;
  int itemno;
  bool (*execfunc)(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue);

  outvalue->value->setbuff(0);
  if (topobject(function, &out, &iid) == true)
    {
      arglength = argument->getarraylength();

      // paint
      // transfer message to frame object
      if (out == std::string("frame"))
	{
	  if (shrinkobject(function, &shrunk))
	    {
	      if (iid < farray->getarraylength() && iid >= 0)
		{
		  if ((*farray)[iid].exec(&shrunk, argument, outvalue))
		    return true;
		  else
		    return false;
		}
	      else if (iid == -2)  // only current frame
		{
		  if (currentframe >= farray->getarraylength() || currentframe < 0)
		    return false;

		  if ((*farray)[currentframe].exec(&shrunk, argument, outvalue))
		    return true;
		  else
		    return false;
		}
	      // selected
	      else if (iid == -3)
		{
		  for (int i = 0; i < farray->getarraylength(); i++)
		    {
		      if ((*farray)[i].selected)
			{
			  if (!(*farray)[i].exec(&shrunk, argument, outvalue))
			    return false;
			}
		    }
		  return true;
		}
	      // all
	      else if (iid == -4)
		{
		  for (int i = 0; i < farray->getarraylength(); i++)
		    {
		      if (!(*farray)[i].exec(&shrunk, argument, outvalue))
			return false;
		    }
		  return true;
		}
	      // first selected
	      else if (iid == -5)
		{
		  for (int i = 0; i < farray->getarraylength(); i++)
		    {
		      if ((*farray)[i].selected)
			{
			  if ((*farray)[i].exec(&shrunk, argument, outvalue))
			    return true;
			  else
			    return false;
			}
		    }
		  return true;
		}
	      else
		return false;
	    }
	  else
	    return false;
	}
      // transfer message to gbuffer
      else if (out == std::string("buffer"))
	{
	  if (shrinkobject(function, &shrunk))
	    {
	      if (gbuffer->exec(&shrunk, argument, outvalue))
		return true;
	      else
		return false;
	    }
	  else
	    return false;
	}
      // transfer message to init
      else if (out == std::string("init"))
	{
	  if (shrinkobject(function, &shrunk))
	    {
	      if (init->exec(&shrunk, argument, outvalue))
		return true;
	      else
		return false;
	    }
	  else
	    return false;
	}
      // else
      else
	{
	  grfncs = grf;
	  for (; grfncs->function; grfncs++)
	    {
	    }
	  itemno = grfncs - grf;
	  for (int i = 0; i < itemno; i++)
	    {
	      if (strcmp(out.c_str(), grf[i].function) == 0)
		{
		  execfunc = grf[i].func;
		  return execfunc(this, arglength, iid, argument, outvalue);
		}
	    }
	  return false;
	}
    }
  else
    return false;
      
  return true;
}

bool graph::setframeid(int arrayno)
{
  bool exist = false;
  for (int i = 0; i <= farray->getarraylength(); i++)
    {
      exist = false;
      for (int j = 0; j < farray->getarraylength(); j++)
	{
	  if ((*farray)[j].id == i && j != arrayno)
	    exist = true;
	}

      if (exist == false)
	{
	  (*farray)[arrayno].id = i;
	  return true;
	}
    }
  return false;
}

bool graph::appendgraph(FILE *fp)
{
  int no, frameno = 0, dataid = 0;
  char stemp[10000], stemp1[1024];
  std::string str;
  char *p;
  frame *fr = 0;
  data *dat = 0;
  char datalabel[10];
  std::string filen, outfilen;
  FILE *out;
  int readversion;

  // version
  if (getnextline(stemp, sizeof(stemp), fp))
  {
    if (nextitem(stemp, &str) != 0)
      readversion = atoi(str.c_str());
    else
      return false;
  }
  else
    return false;

  // graph filename
  if (getnextline(stemp, sizeof(stemp), fp))
  {
    if (gettxt(stemp, &str))
      {
        getcwd(stemp1, sizeof(stemp1));
        strcpy(stemp, tofilename((char *)str.c_str()));
        strcat(stemp1, "/"); strcat(stemp1, stemp);
        strcpy(graphname, stemp1);
//        strncpy(graphname, str.c_str(), 1024);
      }
    else
      return false;
  }
  else
    return false;

  while (getnextline(stemp, sizeof(stemp), fp))
    {
      if (nextitem(stemp, &str))
	{
	  strncpy(datalabel, str.c_str(), 4);
	  datalabel[4] = 0;

	  if (str == std::string("[frame]"))
	    {
	      farray->add(new frame);
	      no = farray->getarraylength() - 1;
	      frameno = no;
	      fr = &(*farray)[no];
	      fr->parent = (void *)this;
	      fr->readframe(fp);
	      setframeid(no);
	      fr->axarray->setbuff(0);
	    }
	  else if (str == std::string("[axis]"))
	    {
	      if (fr != 0)
		{
		  fr->axarray->add(new axis);
		  no = fr->axarray->getarraylength() - 1;
		  (*fr->axarray)[no].parent = (void *)fr;
		  fr->setaxisid(fr->axarray->getarraylength() - 1);
		  (*fr->axarray)[no].readaxis(fp);
		}
	    }
	  else if (str == std::string("[parts]"))
	    {
	      if (fr != 0)
		{
		  fr->parray->add(new parts);
		  no = fr->parray->getarraylength() - 1;
		  (*fr->parray)[no].parent = (void *)fr;
		  fr->setpartsid(fr->parray->getarraylength() - 1);
		  (*fr->parray)[no].readparts(fp);
		}
	    }
	  else if (str == std::string("[data]"))
	    {
	      if (fr != 0)
		{
		  fr->darray->add(new data);
		  no = fr->darray->getarraylength() - 1;
		  dat = &(*fr->darray)[no];
		  dat->parent = (void *)fr;
		  fr->setdataid(fr->darray->getarraylength() - 1);
		  dat->readdata(fp);
		  dataid = dat->id;
		  dat->restoreabspath(graphname);
		}
	    }
	  else if (strcmp(datalabel, "sod[") == 0)
	    {
	      filen = std::string("");
	      p = stemp + 4;
	      while (*p != 0 && *p != ']')
		{
		  stemp1[0] = *p; stemp1[1] = 0;
		  filen += std::string(stemp1);
		  p++;
		}
	      if (*p == 0)
		return false;

	      if (readversion <= 10002)
		{
		  for (int i = 0; i < fr->darray->getarraylength(); i++)
		    {
		      dat = &(*fr->darray)[i];
		      if (strcmp(filen.c_str(), dat->filename) == 0)
			{
			  outfilen = std::string(tmppath);
			  outfilen += std::string("/") + std::string(pid);
			  sprintf(stemp1, "%d_", frameno);
			  outfilen += std::string(stemp1);
			  sprintf(stemp1, "%d_", dat->id);
			  outfilen += std::string(stemp1);
			  outfilen += filen;
			  if ((out = fopen(outfilen.c_str(), "w")) == 0) 
			    return false;
			  while(topazfgets(stemp, sizeof(stemp), fp) != NULL)
			    {
			      if (strcmp(stemp, "eod\n") != 0)
				fputs(stemp, out);
			      else
				break;
			    }
			  fclose(out);
			}
		    }
		}
	      else
		{
		  outfilen = std::string(tmppath);
		  outfilen += std::string("/") + std::string(pid);
		  sprintf(stemp1, "%d_", frameno);
		  outfilen += std::string(stemp1);
		  sprintf(stemp1, "%d_", dataid);
		  outfilen += std::string(stemp1);
		  outfilen += filen;
		  if ((out = fopen(outfilen.c_str(), "w")) == 0) 
		    return false;
		  while(topazfgets(stemp, sizeof(stemp), fp) != NULL)
		    {
		      if (strcmp(stemp, "eod\n") != 0)
			fputs(stemp, out);
		      else
			break;
		    }
		  fclose(out);
		}
	    }
	}
      else
	return false;
    }

  for (int i = 0; i < farray->getarraylength(); i++)
    {
      fr = &(*farray)[i];
      for (int j = 0; j < fr->darray->getarraylength(); j++)
	{
	  dat = &(*fr->darray)[j];
	  if (dat->isfiledata)
	    dat->loaddata();
	  else
	    {
	      if (!genxdata(dat->m_start, dat->m_end, dat->m_div, dat->m_scaling, dat->x, dat->y))
		{
		  message("Error: cannot generate curve!!\n");
		  return false;
		}
	    }
	}
    }

  return true;
}

bool graph::readgraph(FILE *fp)
{
  bool flag;
  farray->setbuff(0);
  currentframe = 0;
  flag = appendgraph(fp);
  showsepwin();
  return flag;
}

bool graph::writegraph(FILE *fp)
{
  frame *fr = 0;
  data *dat = 0;
  char file[100];
  
  fprintf(fp, "# topaz graph format\n");
  fprintf(fp, "%d\n", version);
  fprintf(fp, "\"%s\"\n", graphname);

  for (int i = 0; i < farray->getarraylength(); i++)
    {
      fr = &(*farray)[i];

      //frame
      fr->writeframe(fp);
      
      // axis
      for (int j = 0; j < fr->axarray->getarraylength(); j++)
	(*fr->axarray)[j].writeaxis(fp);

      // parts
      for (int j = 0; j < fr->parray->getarraylength(); j++)
	(*fr->parray)[j].writeparts(fp);

      // if non-withdata, check the existence of non-virgin data
      if (!checkfileexist())
	  return false;

      // if withdata and virgin, copy original files to buffer 
      if ((*farray)[i].withdata)
	{
	  for (int k = 0; k < (*farray)[i].darray->getarraylength(); k++)
	    {
	      dat = &(*fr->darray)[k];
	      if (dat->virgin)
		{
		  loadtobuff(dat->filename, fr->id, dat->id);
		  strcpy(file, toshortfilename(dat->filename));
		  strcpy(dat->filename, file);
		  dat->virgin = false;
		}
	    }
	}

      // change data filename (abs->ref path)
      for (int k = 0; k < (*farray)[i].darray->getarraylength(); k++)
	{
	  dat = &(*fr->darray)[k];
	  dat->setrefpath(graphname);
	}

      for (int j = 0; j < fr->darray->getarraylength(); j++)
	{
	  dat = &(*fr->darray)[j];
	  dat->writedata(fp);

	  if ((*farray)[i].withdata)
	    {
	      if (dat->isfiledata)
		    dat->appendoriginaldata(fp, dat->id);
	    }
	}
    }

  showsepwin();
  return true;
}

bool graph::checkfileexist()
{
  frame *fr;
  data  *dat;
  char stemp[1000];
  FILE *fp;

  for (int i = 0; i < farray->getarraylength(); i++)
    {
      fr = &(*farray)[i];
      if (!fr->withdata)
	{
	  for (int j = 0; j < fr->darray->getarraylength(); j++)
	    {
	      dat = &(*fr->darray)[j];
	      if (dat->virgin && dat->isfiledata)
//	      if (dat->virgin)
		{
		  if ((fp = fopen(dat->filename, "r")) == NULL)
		    {
		      message("Error!!: Cannot refer to original file\n");
		      sprintf(stemp, "frame[%d]->data[%d]\n", i, j);
		      message("Could not save correctly!!\n");
		      message(stemp);
		      return false;
		    }
		  else
		    fclose(fp);
		}
	    }
	}
    }
  return true;
}

bool graph::loadtobuff(char *infile, int frameid, int dataid)
{
  FILE *in, *out;
  char outfile[1000];
  char buff[10000], stemp[100];

  strcpy(outfile, tmppath);
  strcat(outfile, "/");
  strcat(outfile, pid);
  sprintf(stemp, "%d_", frameid);
  strcat(outfile, stemp);
  sprintf(stemp, "%d_", dataid);
  strcat(outfile, stemp);
  strcat(outfile, toshortfilename(infile));

  if ((in = fopen(infile, "r")) == NULL)
      return false;
  if ((out = fopen(outfile, "w")) == NULL)
    {
      fclose(in);
      return false;
    }
  while(topazfgets(buff, sizeof(buff), in) != NULL)
    {
      if (strlen(buff) > 0)
	{
	  if (buff[strlen(buff) - 1] == '\n')
	    {
	      if (strlen(buff) > 1 && buff[strlen(buff) - 2] == '\r')
		{
		  buff[strlen(buff) - 2] = '\n';
		  buff[strlen(buff) - 1] = '\0';
		}
	    }
	  fputs(buff, out);
	}
    }

  fclose(in);
  fclose(out);
  return true;
}

void graph::flushtmpfiles()
{
  DIR *dp;
  struct dirent *entry;
  std::string str1;
  fileentarray *filearray;
  std::string delfiles;
  char stemp[100];

  strcpy(stemp, "^");
  strcat(stemp, pid);

  filearray = new fileentarray;
  if (filearray == 0)
    return;

  if ((dp = opendir(tmppath)) == NULL)
    return;

  while ((entry = readdir(dp)) != NULL)
    {
      str1 = std::string(entry->d_name);
      if (simplematch(str1.c_str(), stemp))
	{
	  filearray->add(new fileentry);
	  strcpy((*filearray)[filearray->getarraylength() - 1].filename, entry->d_name);
	}
    }
  closedir (dp);
  

  for (int i = 0; i < filearray->getarraylength(); i++)
    {
      delfiles = std::string(tmppath) + std::string("/") + std::string((*filearray)[i].filename);
      unlink(delfiles.c_str());
    }
  delete filearray;
}

bool graph::drawpaper(bool flag, FILE *f)
{
  plinestyle(flag, f, 0, 0, 0, 0);
  psetforecolor(flag, f, 0, 0, 0);
  pbeginpath(flag, f);
  pmoveto(flag, f, 0, 0);
  plineto(flag, f, papersize.x, 0);
  plineto(flag, f, papersize.x, papersize.y);
  plineto(flag, f, 0, papersize.y);
  plineto(flag, f, 0, 0);
  pstroke(flag, f);
  return true;
}


int graph::scale(int x)
{
  return x;
}

void graph::versionstring(char *s)
{
  int majorv, minorv, betav;
  char majorstr[100], minorstr[100], betastr[100];

  majorv = version / 10000;
  minorv = (version - 10000 * majorv) / 100;
  betav = version - 10000 * majorv - 100 * minorv;

  sprintf(majorstr, "%d.", majorv);
  sprintf(minorstr, "%02d", minorv);

  if (betav != 99)
    sprintf(betastr, " beta %d ", betav);
  else
    strcpy(betastr, "");

  strcpy(s, majorstr);
  strcat(s, minorstr);
  strcat(s, betastr);
}