1 /*----------------------------------------------------------------------------
2                        graph.cc (graph object definition)
3                        This file is a part of topaz systems
4                   Copyright: Hisao Kawaura, All rights reserved
5                                    1997 - 99
6 
7 
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12 
13     This program is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17 
18     You should have received a copy of the GNU General Public License
19     along with this program; if not, write to the Free Software
20     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21 
22 ----------------------------------------------------------------------------*/
23 
24 #include <string>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <dirent.h>
28 #include <unistd.h>
29 #include "graph.h"
30 #include "frame.h"
31 #include "data.h"
32 #include "vect.h"
33 #include "vectdefs.h"
34 #include "col.h"
35 #include "styledisp.h"
36 #include "browse.h"
37 #include "gdi.h"
38 #include "filepoint.h"
39 #include "linearfit.h"
40 #include "system.h"
41 #include "convtxt.h"
42 #include "regexpress.h"
43 #include "paths.h"
44 
45 extern FileHandleArray *fhvuff;
46 extern void message(const char *msg);
47 
48 FILE *fout, *fview;
49 extern char confpath[1000];
50 extern char tmppath[1000];
51 extern char *toshortfilename(char *in);
52 extern char pid[100];
53 extern bool isabort();
54 extern void resetabort();
55 extern void showsepwin();
56 extern bool genxdata(double start, double end, int div, int scaling, earray* outx, earray* outy);
57 
graph()58 graph :: graph() : plobj()
59 {
60 
61   farray = new framearray;
62   farray->add(new frame);
63   (*farray)[farray->getarraylength() - 1].parent = (void *)this;
64   setframeid(farray->getarraylength() - 1);
65 
66   gbuffer = new globalbuff;
67   init = new globalbuff;
68 
69   // this is the topaz version
70   // ex. version 1.23.beta1 = 12301
71   version = 34199;
72 
73   mag = 1.0;
74   autoscalemargin = 10;
75   currentframe = 0;
76   strcpy(graphname, "untitled.tpz");
77   offset.x = 0;
78   offset.y = 0;
79   papersize.x = 11905;
80   papersize.y = 16440;
81   updated = false;
82 
83   fout = 0;
84   fout = fview;
85 }
86 
~graph()87 graph :: ~graph()
88 {
89   delete farray;
90   delete gbuffer;
91   delete init;
92 }
93 
get(std::string * member,tokenbuff * outvalue)94 bool graph::get(std::string* member, tokenbuff* outvalue)
95 {
96   std::string out, shrunk;
97   int iid;
98   char stemp[1024];
99 
100   if (topobject(member, &out, &iid) == true)
101     {
102       if (out == std::string("frame"))
103 	{
104 	  if (shrinkobject(member, &shrunk))
105 	    {
106 	      if (iid < farray->getarraylength() && iid >= 0)
107 		{
108 		  if ((*farray)[iid].get(&shrunk, outvalue))
109 		    return true;
110 		  else
111 		    return false;
112 		}
113 	      else if (iid == -2)
114 		{
115 		  if ((*farray)[currentframe].get(&shrunk, outvalue))
116 		    return true;
117 		  else
118 		    return false;
119 		}
120 	      // first selected
121 	      else if (iid == -5)
122 		{
123 		  for (int i = 0; i < farray->getarraylength(); i++)
124 		    {
125 		      if ((*farray)[i].selected)
126 			{
127 			  if ((*farray)[i].get(&shrunk, outvalue))
128 			    return true;
129 			  else
130 			    return false;
131 			}
132 		    }
133 		  outvalue->value->add("");
134 		  return false;
135 		}
136 	      else
137 		return false;
138 	    }
139 	  else
140 	    return false;
141 	}
142       else if (out == std::string("version") && iid == -1)
143 	{
144 	  versionstring(stemp);
145 	  outvalue->value->add(stemp);
146 	  return true;
147 	}
148       else if (out == std::string("versionnumber") && iid == -1)
149 	{
150 	  sprintf(stemp, "%d", version);
151 	  outvalue->value->add(stemp);
152 	  return true;
153 	}
154       else if (out == std::string("mag") && iid == -1)
155 	{
156 	  sprintf(stemp, "%.15g", mag);
157 	  outvalue->value->add(stemp);
158 	  return true;
159 	}
160       else if (out == std::string("graphname") && iid == -1)
161 	{
162 	  sprintf(stemp, "%s", graphname);
163 	  outvalue->value->add(stemp);
164 	  return true;
165 	}
166       else if (out == std::string("offset_x") && iid == -1)
167 	{
168 	  sprintf(stemp, "%d", offset.x);
169 	  outvalue->value->add(stemp);
170 	  return true;
171 	}
172       else if (out == std::string("offset_y") && iid == -1)
173 	{
174 	  sprintf(stemp, "%d", offset.y);
175 	  outvalue->value->add(stemp);
176 	  return true;
177 	}
178       else if (out == std::string("papersize_x") && iid == -1)
179 	{
180 	  sprintf(stemp, "%d", papersize.x);
181 	  outvalue->value->add(stemp);
182 	  return true;
183 	}
184       else if (out == std::string("papersize_y") && iid == -1)
185 	{
186 	  sprintf(stemp, "%d", papersize.y);
187 	  outvalue->value->add(stemp);
188 	  return true;
189 	}
190       else if (out == std::string("autoscalemargin") && iid == -1)
191 	{
192 	  sprintf(stemp, "%d", autoscalemargin);
193 	  outvalue->value->add(stemp);
194 	  return true;
195 	}
196       else if (out == std::string("currentframe") && iid == -1)
197 	{
198 	  sprintf(stemp, "%d", currentframe);
199 	  outvalue->value->add(stemp);
200 	  return true;
201 	}
202       else if (out == std::string("updated") && iid == -1)
203 	{
204 	  sprintf(stemp, "%d", updated);
205 	  outvalue->value->add(stemp);
206 	  return true;
207 	}
208       else
209 	return false;
210     }
211   else
212     return false;
213 
214   return true;
215 }
216 
set(std::string * member,std::string * setvalue)217 bool graph::set(std::string* member, std::string* setvalue)
218 {
219   std::string out, shrunk;
220   int iid;
221 
222   if (topobject(member, &out, &iid) == true)
223     {
224       if (out == std::string("frame"))
225 	{
226 	  if (shrinkobject(member, &shrunk))
227 	    {
228 	      if (iid < farray->getarraylength() && iid >= 0)
229 		{
230 		  if ((*farray)[iid].set(&shrunk, setvalue))
231 		    {
232 		      updated = true;
233 		      return true;
234 		    }
235 		  else
236 		    return false;
237 		}
238 	      // current
239 	      else if (iid == -2)
240 		{
241 		  if ((*farray)[currentframe].set(&shrunk, setvalue))
242 		    {
243 		      updated = true;
244 		      return true;
245 		    }
246 		  else
247 		    return false;
248 		}
249 	      // selected
250 	      else if (iid == -3)
251 		{
252 		  for (int i = 0; i < farray->getarraylength(); i++)
253 		    {
254 		      if ((*farray)[i].selected)
255 			{
256 			  if (!(*farray)[i].set(&shrunk, setvalue))
257 			    return false;
258 			}
259 		    }
260 		  updated = true;
261 		  return true;
262 		}
263 	      // all
264 	      else if (iid == -4)
265 		{
266 		  for (int i = 0; i < farray->getarraylength(); i++)
267 		    {
268 		      if (!(*farray)[i].set(&shrunk, setvalue))
269 			return false;
270 		    }
271 		  updated = true;
272 		  return true;
273 		}
274 	      else
275 		return false;
276 	    }
277 	  else
278 	    return false;
279 	}
280       else if (out == std::string("mag") && iid == -1)
281 	{
282 	  mag = atof(setvalue->c_str());
283 	  return true;
284 	}
285       else if (out == std::string("graphname") && iid == -1)
286 	{
287 	  strncpy(graphname,setvalue->c_str(), 1024);
288 	  return true;
289 	}
290       else if (out == std::string("offset_x") && iid == -1)
291 	{
292 	  offset.x = atoi(setvalue->c_str());
293 	  return true;
294 	}
295       else if (out == std::string("offset_y") && iid == -1)
296 	{
297 	  offset.y = atoi(setvalue->c_str());
298 	  return true;
299 	}
300       else if (out == std::string("papersize_x") && iid == -1)
301 	{
302 	  papersize.x = atoi(setvalue->c_str());
303 	  return true;
304 	}
305       else if (out == std::string("papersize_y") && iid == -1)
306 	{
307 	  papersize.y = atoi(setvalue->c_str());
308 	  return true;
309 	}
310       else if (out == std::string("autoscalemargin") && iid == -1)
311 	{
312 	  autoscalemargin = atoi(setvalue->c_str());
313 	  return true;
314 	}
315       else if (out == std::string("currentframe") && iid == -1)
316 	{
317 	  if ( atoi(setvalue->c_str()) < farray->getarraylength() && atoi(setvalue->c_str()) >= 0)
318 	    currentframe = atoi(setvalue->c_str());
319 	  else
320 	    return false;
321 	  return true;
322 	}
323       else if (out == std::string("updated") && iid == -1)
324 	{
325 	  updated = atoi(setvalue->c_str());
326 	  return true;
327 	}
328       else
329 	return false;
330     }
331   else
332     return false;
333 
334   return true;
335 }
336 
337 
gra_paintall(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)338 bool gra_paintall(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
339 {
340   std::string str1, str3;
341   int itemp;
342   FILE *fp;
343 
344   if (gra == 0 || outvalue == 0)
345     return false;
346 
347   if (arglength == 1 && iid == -1)
348     {
349       if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
350 	{
351 	  resetabort();
352 	  pbegin(true, fp);
353 	  pclearviewer(true, fp);
354 
355 	  // execute child objects
356 	  //frame
357 	  for (int i = 0; i < gra->farray->getarraylength(); i++)
358 	    {
359 	      str3 = std::string("paint");
360 	      if (!(*gra->farray)[i].exec(&str3, argument, outvalue))
361 		return false;
362 	    }
363 
364 	  ppaint(true, fp);
365 	  pflush(true, fp);
366 
367 	  return true;
368 	}
369       else
370 	return false;
371     }
372   else
373     return false;
374 }
375 
gra_paint(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)376 bool gra_paint(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
377 {
378   FILE *fp;
379   std::string str1, str3;
380   int itemp;
381 
382   if (gra == 0 || outvalue == 0)
383     return false;
384 
385   if (arglength == 1 && iid == -1)
386     {
387       if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
388 	{
389 	  // execute child objects
390 	  //frame
391 	  for (int i = 0; i < gra->farray->getarraylength(); i++)
392 	    {
393 	      str3 = std::string("paint");
394 	      if (!(*gra->farray)[i].exec(&str3, argument, outvalue))
395 		return false;
396 	    }
397 	  return true;
398 	}
399       else
400 	return false;
401     }
402   else
403     return false;
404 }
405 
gra_preout(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)406 bool gra_preout(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
407 {
408   std::string str1;
409   FILE *fp;
410   int itemp;
411 
412   if (gra == 0 || outvalue == 0)
413     return false;
414 
415   if (arglength == 1 && iid == -1)
416     {
417       if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
418 	{
419 	  resetabort();
420 	  pbegin(true, fp);
421 	  pclearviewer(true, fp);
422 	  return true;
423 	}
424       else
425 	return false;
426     }
427   else
428     return false;
429 }
430 
gra_postout(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)431 bool gra_postout(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
432 {
433   std::string str1;
434   FILE *fp;
435   int itemp;
436 
437   if (gra == 0 || outvalue == 0)
438     return false;
439 
440   if (arglength == 1 && iid == -1)
441     {
442       if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
443 	{
444 	  ppaint(true, fp);
445 	  pflush(true, fp);
446 	  return true;
447 	}
448       else
449 	return false;
450     }
451   else
452     return false;
453 }
454 
gra_drawpaper(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)455 bool gra_drawpaper(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
456 {
457   std::string str1;
458   FILE *fp;
459   int itemp;
460 
461   if (gra == 0 || outvalue == 0)
462     return false;
463 
464   if (arglength == 1 && iid == -1)
465     {
466       if (fhvuff->get(&(*argument)[0], &fp, &itemp, &str1))
467 	{
468 	  gra->drawpaper(true, fp);
469 	  return true;
470 	}
471       else
472 	return false;
473     }
474   else
475     return false;
476 }
477 
gra_setbbox(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)478 bool gra_setbbox(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
479 {
480   std::string str3;
481 
482   if (gra == 0 || outvalue == 0)
483     return false;
484 
485   if (arglength == 1 && iid == -1 && (*argument)[0] == std::string("null"))
486     {
487       // reset bbox
488       pbegin(false, 0);
489       // calc bbox
490       for (int i = 0; i < gra->farray->getarraylength(); i++)
491 	{
492 	  str3 = std::string("setbbox");
493 	  if (!(*gra->farray)[i].exec(&str3, argument, outvalue))
494 	    return false;
495 	}
496       return true;
497     }
498   else
499     return false;
500 }
501 
gra_gropen(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)502 bool gra_gropen(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
503 {
504   FILE *fp;
505 
506   if (gra == 0 || outvalue == 0)
507     return false;
508 
509   if (arglength == 1 && iid == -1)
510     {
511       if ((fp = fopen((*argument)[0].c_str(), "r")) != 0)
512 	{
513 	  gra->readgraph(fp);
514 	  fclose (fp);
515 	  showsepwin();
516 	  gra->updated = false;
517 	  return true;
518 	}
519       else
520 	return false;
521     }
522   else
523     return false;
524 }
525 
gra_grappend(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)526 bool gra_grappend(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
527 {
528   FILE *fp;
529 
530   if (gra == 0 || outvalue == 0)
531     return false;
532 
533   if (arglength == 1 && iid == -1)
534     {
535       if ((fp = fopen((*argument)[0].c_str(), "r")) != 0)
536 	{
537 	  gra->appendgraph(fp);
538 	  fclose (fp);
539 	  gra->updated = true;
540 	  return true;
541 	}
542       else
543 	return false;
544     }
545   else
546     return false;
547 }
548 
gra_grsave(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)549 bool gra_grsave(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
550 {
551   FILE *fp;
552 
553   if (gra == 0 || outvalue == 0)
554     return false;
555 
556   if (arglength == 1 && iid == -1)
557     {
558       if ((fp = fopen((*argument)[0].c_str(), "w")) != 0)
559 	{
560 	  strcpy(gra->graphname, (*argument)[0].c_str());
561 	  gra->writegraph(fp);
562 	  fclose (fp);
563 	  gra->updated = false;
564 	  return true;
565 	}
566       else
567 	return false;
568     }
569   else
570     return false;
571 }
572 
gra_getindex(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)573 bool gra_getindex(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
574 {
575   char stemp[100];
576 
577   if (gra == 0 || outvalue == 0)
578     return false;
579 
580   if (arglength == 2 && iid == -1)
581     {
582       // frame object
583       if ((*argument)[0] == std::string("frame"))
584 	{
585 	  for (int i = 0; i < gra->farray->getarraylength(); i++)
586 	    {
587 	      if (atoi((*argument)[1].c_str()) == (*gra->farray)[i].id)
588 		{
589 		  sprintf(stemp, "%d", i);
590 		  outvalue->value->add(stemp);
591 		  return true;
592 		}
593 	    }
594 	  return false;
595 	}
596       else
597 	return false;
598     }
599   else
600     return false;
601 }
602 
gra_delete(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)603 bool gra_delete(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
604 {
605 
606   if (gra == 0 || outvalue == 0)
607     return false;
608 
609   if (arglength == 2 && iid == -1)
610     {
611       // frame object
612       if ((*argument)[0] == std::string("frame"))
613 	{
614 	  gra->updated = true;
615 	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength()
616 	      && 0 <= atoi((*argument)[1].c_str()))
617 	    gra->farray->remove(atoi((*argument)[1].c_str()));
618 	  //selected
619 	  else if (atoi((*argument)[1].c_str()) == -3)
620 	    {
621 	      for (int i = gra->farray->getarraylength() - 1; i >= 0; i--)
622 		if ((*gra->farray)[i].selected)
623 		  gra->farray->remove(i);
624 	    }
625 	  //all
626 	  else if (atoi((*argument)[1].c_str()) == -4)
627 	    {
628 	      for (int i = gra->farray->getarraylength() - 1; i >= 0; i--)
629 		gra->farray->remove(i);
630 	    }
631 	  else
632 	    return false;
633 
634 	  if (gra->currentframe > gra->farray->getarraylength() - 1)
635 	    gra->currentframe = 0;
636 	  return true;
637 	}
638       else
639 	return false;
640     }
641   else
642     return false;
643 }
644 
gra_new(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)645 bool gra_new(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
646 {
647   char stemp[100];
648 
649   if (gra == 0 || outvalue == 0)
650     return false;
651 
652   if (arglength == 1 && iid == -1)
653     {
654       // frame object
655       if ((*argument)[0] == std::string("frame"))
656 	{
657 	  gra->updated = true;
658 	  gra->farray->add(new frame);
659 	  (*gra->farray)[gra->farray->getarraylength() - 1].parent = (void *)gra;
660 	  gra->setframeid(gra->farray->getarraylength() - 1);
661 	  sprintf(stemp, "%d", gra->farray->getarraylength());
662 	  outvalue->value->add(stemp);
663 	  return true;
664 	}
665       else
666 	return false;
667     }
668   else
669     return false;
670 }
671 
gra_flushselect(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)672 bool gra_flushselect(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
673 {
674 
675   if (gra == 0 || outvalue == 0)
676     return false;
677 
678   if (arglength == 1 && iid == -1)
679     {
680       // frame object
681       if ((*argument)[0] == std::string("frame"))
682 	{
683 	  for (int i = 0; i < gra->farray->getarraylength(); i++)
684 	    (*gra->farray)[i].selected = false;
685 	  return true;
686 	}
687       else
688 	return false;
689     }
690   else
691     return false;
692 }
693 
gra_length(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)694 bool gra_length(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
695 {
696   char stemp[100];
697 
698   if (gra == 0 || outvalue == 0)
699     return false;
700 
701   if (arglength == 1 && iid == -1)
702     {
703       // frame object
704       if ((*argument)[0] == std::string("frame"))
705 	{
706 	  sprintf(stemp, "%d", gra->farray->getarraylength());
707 	  outvalue->value->add(stemp);
708 	  return true;
709 	}
710       else
711 	return false;
712     }
713   else
714     return false;
715 }
716 
gra_top(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)717 bool gra_top(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
718 {
719 
720   if (gra == 0 || outvalue == 0)
721     return false;
722 
723   if (arglength == 2 && iid == -1)
724     {
725       // frame object
726       if ((*argument)[0] == std::string("frame"))
727 	{
728 	  gra->updated = true;
729 	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength()
730 	      && 0 <= atoi((*argument)[1].c_str()))
731 	    {
732 	      gra->farray->top(atoi((*argument)[1].c_str()));
733 	      return true;
734 	    }
735 	  //first selected
736 	  else if (atoi((*argument)[1].c_str()) == -5)
737 	    {
738 	      for (int i = 0; i < gra->farray->getarraylength(); i++)
739 		{
740 		  if ((*gra->farray)[i].selected)
741 		    {
742 		      gra->farray->top(i);
743 		      return true;
744 		    }
745 		}
746 	      return true;
747 	    }
748 	  else
749 	    return false;
750 	}
751       else
752 	return false;
753     }
754   else
755     return false;
756 }
757 
gra_up(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)758 bool gra_up(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
759 {
760 
761   if (gra == 0 || outvalue == 0)
762     return false;
763 
764   if (arglength == 2 && iid == -1)
765     {
766       // frame object
767       if ((*argument)[0] == std::string("frame"))
768 	{
769 	  gra->updated = true;
770 	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength()
771 	      && 0 <= atoi((*argument)[1].c_str()))
772 	    {
773 	      gra->farray->up(atoi((*argument)[1].c_str()));
774 	      return true;
775 	    }
776 	  //first selected
777 	  else if (atoi((*argument)[1].c_str()) == -5)
778 	    {
779 	      for (int i = 0; i < gra->farray->getarraylength(); i++)
780 		{
781 		  if ((*gra->farray)[i].selected)
782 		    {
783 		      gra->farray->up(i);
784 		      return true;
785 		    }
786 		}
787 	      return true;
788 	    }
789 	  else
790 	    return false;
791 	}
792       else
793 	return false;
794     }
795   else
796     return false;
797 }
798 
gra_down(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)799 bool gra_down(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
800 {
801 
802   if (gra == 0 || outvalue == 0)
803     return false;
804 
805   if (arglength == 2 && iid == -1)
806     {
807       // frame object
808       if ((*argument)[0] == std::string("frame"))
809 	{
810 	  gra->updated = true;
811 	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength()
812 	      && 0 <= atoi((*argument)[1].c_str()))
813 	    {
814 	      gra->farray->down(atoi((*argument)[1].c_str()));
815 	      return true;
816 	    }
817 	  //first selected
818 	  else if (atoi((*argument)[1].c_str()) == -5)
819 	    {
820 	      for (int i = 0; i < gra->farray->getarraylength(); i++)
821 		{
822 		  if ((*gra->farray)[i].selected)
823 		    {
824 		      gra->farray->down(i);
825 		      return true;
826 		    }
827 		}
828 	      return true;
829 	    }
830 	  else
831 	    return false;
832 	}
833       else
834 	return false;
835     }
836   else
837     return false;
838 }
839 
gra_bottom(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)840 bool gra_bottom(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
841 {
842 
843   if (gra == 0 || outvalue == 0)
844     return false;
845 
846   if (arglength == 2 && iid == -1)
847     {
848       // frame object
849       if ((*argument)[0] == std::string("frame"))
850 	{
851 	  gra->updated = true;
852 	  if (atoi((*argument)[1].c_str()) < gra->farray->getarraylength()
853 	      && 0 <= atoi((*argument)[1].c_str()))
854 	    {
855 	      gra->farray->bottom(atoi((*argument)[1].c_str()));
856 	      return true;
857 	    }
858 	  //first selected
859 	  else if (atoi((*argument)[1].c_str()) == -5)
860 	    {
861 	      for (int i = 0; i < gra->farray->getarraylength(); i++)
862 		{
863 		  if ((*gra->farray)[i].selected)
864 		    {
865 		      gra->farray->bottom(i);
866 		      return true;
867 		    }
868 		}
869 	      return true;
870 	    }
871 	  else
872 	    return false;
873 	}
874       else
875 	return false;
876     }
877   else
878     return false;
879 }
880 
gra_copy(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)881 bool gra_copy(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
882 {
883   std::string str1, str2;
884   int itemp1, itemp2;
885 
886   if (gra == 0 || outvalue == 0)
887     return false;
888 
889   if (arglength == 3 && iid == -1)
890     {
891       gra->updated = true;
892       // frame object
893       if ((*argument)[0] == std::string("frame"))
894 	{
895 	  itemp1 = atoi((*argument)[1].c_str());
896 	  itemp2 = atoi((*argument)[2].c_str());
897 
898 	  if (itemp1 < gra->farray->getarraylength()
899 	      && 0 <= itemp1
900 	      && itemp2 < gra->farray->getarraylength()
901 	      && 0 <= itemp2)
902 	    {
903 	      (*gra->farray)[itemp1] = (*gra->farray)[itemp2];
904 
905 	      for (int j = 0; j < (*gra->farray)[itemp2].darray->getarraylength(); j++)
906 		{
907 		  (*(*gra->farray)[itemp1].darray)[j].gettmpdataname(&str1);
908 		  str1 = std::string(tmppath) + std::string("/") + str1;
909 		  (*(*gra->farray)[itemp2].darray)[j].gettmpdataname(&str2);
910 		  str2 = std::string(tmppath) + std::string("/") + str2;
911 		  if (isfileexist((char *)str2.c_str())
912 		      && !(*(*gra->farray)[itemp2].darray)[j].virgin
913 		      && (*gra->farray)[itemp2].withdata)
914 		    filecp((char *)str1.c_str(), (char *)str2.c_str());
915 		}
916 
917 	      return true;
918 	    }
919 	  //first selected
920 	  else if (itemp1 == -5
921 		   && itemp2 < gra->farray->getarraylength()
922 		   && 0 <= itemp2)
923 	    {
924 	      for (int i = 0; i < gra->farray->getarraylength(); i++)
925 		{
926 		  if ((*gra->farray)[i].selected)
927 		    {
928 		      (*gra->farray)[i] = (*gra->farray)[itemp2];
929 
930 		      for (int j = 0; j < (*gra->farray)[itemp2].darray->getarraylength(); j++)
931 			{
932 			  (*(*gra->farray)[i].darray)[j].gettmpdataname(&str1);
933 			  str1 = std::string(tmppath) + std::string("/") + str1;
934 			  (*(*gra->farray)[itemp2].darray)[j].gettmpdataname(&str2);
935 			  str2 = std::string(tmppath) + std::string("/") + str2;
936 			  if (isfileexist((char *)str2.c_str())
937 			      && !(*(*gra->farray)[itemp2].darray)[j].virgin
938 			      && (*gra->farray)[itemp2].withdata)
939 			    filecp((char *)str1.c_str(), (char *)str2.c_str());
940 			}
941 
942 		      return true;
943 		    }
944 		}
945 	      return true;
946 	    }
947 	  else if (itemp1 < gra->farray->getarraylength()
948 		   && 0 <= itemp1
949 		   && itemp2  == -5)
950 	    {
951 	      for (int i = 0; i < gra->farray->getarraylength(); i++)
952 		{
953 		  if ((*gra->farray)[i].selected)
954 		    {
955 		      (*gra->farray)[itemp1] = (*gra->farray)[i];
956 
957 		      for (int j = 0; j < (*gra->farray)[i].darray->getarraylength(); j++)
958 			{
959 			  (*(*gra->farray)[itemp1].darray)[j].gettmpdataname(&str1);
960 			  str1 = std::string(tmppath) + std::string("/") + str1;
961 			  (*(*gra->farray)[i].darray)[j].gettmpdataname(&str2);
962 			  str2 = std::string(tmppath) + std::string("/") + str2;
963 			  if (isfileexist((char *)str2.c_str())
964 			      && !(*(*gra->farray)[i].darray)[j].virgin
965 			      && (*gra->farray)[i].withdata)
966 			    filecp((char *)str1.c_str(), (char *)str2.c_str());
967 			}
968 
969 		      return true;
970 		    }
971 		}
972 	      return true;
973 	    }
974 	  else
975 	    return false;
976 	}
977       else
978 	return false;
979     }
980   else
981     return false;
982 }
983 
gra_selectednumber(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)984 bool gra_selectednumber(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
985 {
986   char stemp[100];
987   int itemp;
988 
989   if (gra == 0 || outvalue == 0)
990     return false;
991 
992   if (arglength == 1 && iid == -1)
993     {
994       // frame object
995       if ((*argument)[0] == std::string("frame"))
996 	{
997 	  itemp = 0;
998 	  for (int i = 0; i < gra->farray->getarraylength(); i++)
999 	    {
1000 	      if ((*gra->farray)[i].selected)
1001 		itemp++;
1002 	    }
1003 	  sprintf(stemp, "%d", itemp);
1004 	  outvalue->value->add(stemp);
1005 	  return true;
1006 	}
1007       else
1008 	return false;
1009     }
1010   else
1011     return false;
1012 }
1013 
gra_getframetypename(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1014 bool gra_getframetypename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1015 {
1016   std::string str1;
1017 
1018   if (gra == 0 || outvalue == 0)
1019     return false;
1020 
1021   if (arglength == 1 && iid == -1)
1022     {
1023       if (getframetypename(atoi((*argument)[0].c_str()), &str1))
1024 	{
1025 	  outvalue->value->add(str1.c_str());
1026 	  return true;
1027 	}
1028       else
1029 	return false;
1030     }
1031   else
1032     return false;
1033 }
1034 
gra_getlinestylename(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1035 bool gra_getlinestylename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1036 {
1037   std::string str1;
1038 
1039   if (gra == 0 || outvalue == 0)
1040     return false;
1041 
1042   if (arglength == 1 && iid == -1)
1043     {
1044       if (getlinestylename(atoi((*argument)[0].c_str()), &str1))
1045 	{
1046 	  outvalue->value->add(str1.c_str());
1047 	  return true;
1048 	}
1049       else
1050 	return false;
1051     }
1052   else
1053     return false;
1054 }
1055 
gra_getlinecapname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1056 bool gra_getlinecapname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1057 {
1058 
1059   if (gra == 0 || outvalue == 0)
1060     return false;
1061 
1062   if (arglength == 1 && iid == -1)
1063     {
1064       switch(atoi((*argument)[0].c_str()))
1065 	{
1066 	case LINECAPBUTT:
1067 	  outvalue->value->add("butt");
1068 	  break;
1069 	case LINECAPROUND:
1070 	  outvalue->value->add("round");
1071 	  break;
1072 	case LINECAPPROJECTING:
1073 	  outvalue->value->add("projecting");
1074 	  break;
1075 	default:
1076 	  return false;
1077 	}
1078       return true;
1079     }
1080   else
1081     return false;
1082 }
1083 
gra_getlinejoinname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1084 bool gra_getlinejoinname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1085 {
1086 
1087   if (gra == 0 || outvalue == 0)
1088     return false;
1089 
1090   if (arglength == 1 && iid == -1)
1091     {
1092       switch(atoi((*argument)[0].c_str()))
1093 	{
1094 	case LINEJOINMITER:
1095 	  outvalue->value->add("miter");
1096 	  break;
1097 	case LINEJOINROUND:
1098 	  outvalue->value->add("round");
1099 	  break;
1100 	case LINEJOINBEVEL:
1101 	  outvalue->value->add("bevel");
1102 	  break;
1103 	default:
1104 	  return false;
1105 	}
1106       return true;
1107     }
1108   else
1109     return false;
1110 }
1111 
gra_getinterpolationname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1112 bool gra_getinterpolationname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1113 {
1114 
1115   if (gra == 0 || outvalue == 0)
1116     return false;
1117 
1118   if (arglength == 1 && iid == -1)
1119     {
1120       switch(atoi((*argument)[0].c_str()))
1121 	{
1122 	case INTER_POLYLINE:
1123 	  outvalue->value->add("polyline");
1124 	  break;
1125 	case INTER_CLOSEDPOLYLINE:
1126 	  outvalue->value->add("closed polyline");
1127 	  break;
1128 	case INTER_SPLINE:
1129 	  outvalue->value->add("spline");
1130 	  break;
1131 	case INTER_PSPLINE:
1132 	  outvalue->value->add("Pspline");
1133 	  break;
1134 	case INTER_CLOSEDPSPLINE:
1135 	  outvalue->value->add("closed Pspline");
1136 	  break;
1137 	case INTER_BSPLINE:
1138 	  outvalue->value->add("Bspline");
1139 	  break;
1140 	case INTER_CLOSEDBSPLINE:
1141 	  outvalue->value->add("closed Bspline");
1142 	  break;
1143 	default:
1144 	  return false;
1145 	}
1146       return true;
1147     }
1148   else
1149     return false;
1150 }
1151 
gra_getfillstylename(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1152 bool gra_getfillstylename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1153 {
1154 
1155   if (gra == 0 || outvalue == 0)
1156     return false;
1157 
1158   if (arglength == 1 && iid == -1)
1159     {
1160       switch(atoi((*argument)[0].c_str()))
1161 	{
1162 	case FILLSTYLESOLID:
1163 	  outvalue->value->add("solid");
1164 	  break;
1165 	case FILLSTYLENULL:
1166 	  outvalue->value->add("null");
1167 	  break;
1168 	default:
1169 	  return false;
1170 	}
1171       return true;
1172     }
1173   else
1174     return false;
1175 }
1176 
gra_getcolorname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1177 bool gra_getcolorname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1178 {
1179   std::string str1;
1180   unsigned short r, g, b;
1181 
1182   if (gra == 0 || outvalue == 0)
1183     return false;
1184 
1185   if (arglength == 3 && iid == -1)
1186     {
1187       r = (unsigned short)atoi((*argument)[0].c_str());
1188       g = (unsigned short)atoi((*argument)[1].c_str());
1189       b = (unsigned short)atoi((*argument)[2].c_str());
1190 
1191       getcolorname(r, g, b, &str1);
1192       outvalue->value->add(str1.c_str());
1193       return true;
1194     }
1195   else
1196     return false;
1197 }
1198 
gra_getscalingname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1199 bool gra_getscalingname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1200 {
1201 
1202   if (gra == 0 || outvalue == 0)
1203     return false;
1204 
1205   if (arglength == 1 && iid == -1)
1206     {
1207       switch(atoi((*argument)[0].c_str()))
1208 	{
1209 	case SCALE_LINEAR:
1210 	  outvalue->value->add("linear");
1211 	  break;
1212 	case SCALE_LOG:
1213 	  outvalue->value->add("log");
1214 	  break;
1215 	case SCALE_INV:
1216 	  outvalue->value->add("inverse");
1217 	  break;
1218 	case SCALE_LOGLINEAR:
1219 	  outvalue->value->add("log (linear)");
1220 	  break;
1221 	case SCALE_INVLINEAR:
1222 	  outvalue->value->add("inverse (linear)");
1223 	  break;
1224 	default:
1225 	  return false;
1226 	}
1227       return true;
1228     }
1229   else
1230     return false;
1231 }
1232 
gra_getcommentlineactionname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1233 bool gra_getcommentlineactionname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1234 {
1235 
1236   if (gra == 0 || outvalue == 0)
1237     return false;
1238 
1239   if (arglength == 1 && iid == -1)
1240     {
1241       switch(atoi((*argument)[0].c_str()))
1242 	{
1243 	case COMMENT_ABORT:
1244 	  outvalue->value->add("abort");
1245 	  break;
1246 	case COMMENT_IGNORE:
1247 	  outvalue->value->add("ignore");
1248 	  break;
1249 	case COMMENT_SEPARTION:
1250 	  outvalue->value->add("separate");
1251 	  break;
1252 	default:
1253 	  return false;
1254 	}
1255       return true;
1256     }
1257   else
1258     return false;
1259 }
1260 
gra_getlabelparityname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1261 bool gra_getlabelparityname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1262 {
1263 
1264   if (gra == 0 || outvalue == 0)
1265     return false;
1266 
1267   if (arglength == 1 && iid == -1)
1268     {
1269       switch(atoi((*argument)[0].c_str()))
1270 	{
1271 	case LABELPARITY_PLUS:
1272 	  outvalue->value->add("plus");
1273 	  break;
1274 	case LABELPARITY_MINUS:
1275 	  outvalue->value->add("minus");
1276 	  break;
1277 	default:
1278 	  return false;
1279 	}
1280       return true;
1281     }
1282   else
1283     return false;
1284 }
1285 
gra_getlabelcpparityname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1286 bool gra_getlabelcpparityname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1287 {
1288 
1289   if (gra == 0 || outvalue == 0)
1290     return false;
1291 
1292   if (arglength == 1 && iid == -1)
1293     {
1294       switch(atoi((*argument)[0].c_str()))
1295 	{
1296 	case CROSSPOINTPARITY_CENTER:
1297 	  outvalue->value->add("zero");
1298 	  break;
1299 	case CROSSPOINTPARITY_MINUS:
1300 	  outvalue->value->add("minus");
1301 	  break;
1302 	case CROSSPOINTPARITY_PLUS:
1303 	  outvalue->value->add("plus");
1304 	  break;
1305 	case CROSSPOINTPARITY_NULL:
1306 	  outvalue->value->add("null");
1307 	  break;
1308 	default:
1309 	  return false;
1310 	}
1311       return true;
1312     }
1313   else
1314     return false;
1315 }
1316 
gra_getlabelformatname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1317 bool gra_getlabelformatname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1318 {
1319 
1320   if (gra == 0 || outvalue == 0)
1321     return false;
1322 
1323   if (arglength == 1 && iid == -1)
1324     {
1325       switch(atoi((*argument)[0].c_str()))
1326 	{
1327 	case LABEL_FORMAT_NULL:
1328 	  outvalue->value->add("null");
1329 	  break;
1330 	case LABEL_FORMAT_DECIMAL:
1331 	  outvalue->value->add("decimal");
1332 	  break;
1333 	case LABEL_FORMAT_EXP:
1334 	  outvalue->value->add("exp.");
1335 	  break;
1336 	default:
1337 	  return false;
1338 	}
1339       return true;
1340     }
1341   else
1342     return false;
1343 }
1344 
gra_getpartsname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1345 bool gra_getpartsname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1346 {
1347   std::string str1;
1348 
1349   if (gra == 0 || outvalue == 0)
1350     return false;
1351 
1352   if (arglength == 1 && iid == -1)
1353     {
1354       if (getpartsname(atoi((*argument)[0].c_str()), &str1))
1355 	{
1356 	  outvalue->value->add(str1.c_str());
1357 	  return true;
1358 	}
1359       else
1360 	return false;
1361     }
1362   else
1363     return false;
1364 }
1365 
gra_gettextfacename(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1366 bool gra_gettextfacename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1367 {
1368   std::string str1;
1369 
1370   if (gra == 0 || outvalue == 0)
1371     return false;
1372 
1373   if (arglength == 1 && iid == -1)
1374     {
1375       if (gettextfacename(atoi((*argument)[0].c_str()), &str1))
1376 	{
1377 	  outvalue->value->add(str1.c_str());
1378 	  return true;
1379 	}
1380       else
1381 	return false;
1382     }
1383   else
1384     return false;
1385 }
1386 
gra_gettextjpfacename(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1387 bool gra_gettextjpfacename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1388 {
1389   std::string str1;
1390 
1391   if (gra == 0 || outvalue == 0)
1392     return false;
1393 
1394   if (arglength == 1 && iid == -1)
1395     {
1396       if (gettextjpfacename(atoi((*argument)[0].c_str()), &str1))
1397 	{
1398 	  outvalue->value->add(str1.c_str());
1399 	  return true;
1400 	}
1401       else
1402 	return false;
1403     }
1404   else
1405     return false;
1406 }
1407 
gra_getlinearfitfunctionname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1408 bool gra_getlinearfitfunctionname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1409 {
1410   std::string str1;
1411 
1412   if (gra == 0 || outvalue == 0)
1413     return false;
1414 
1415   if (arglength == 1 && iid == -1)
1416     {
1417       if (getlinearfitfunctionname(atoi((*argument)[0].c_str()), &str1))
1418 	{
1419 	  outvalue->value->add(str1.c_str());
1420 	  return true;
1421 	}
1422       else
1423 	return false;
1424     }
1425   else
1426     return false;
1427 }
1428 
gra_getdatasearchpathname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1429 bool gra_getdatasearchpathname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1430 {
1431 
1432   if (gra == 0 || outvalue == 0)
1433     return false;
1434 
1435   if (arglength == 1 && iid == -1)
1436     {
1437       switch(atoi((*argument)[0].c_str()))
1438 	{
1439 	case PATH_ABSOLUTE:
1440 	  outvalue->value->add("absolute");
1441 	  break;
1442 	case PATH_RELATIVE:
1443 	  outvalue->value->add("relative");
1444 	  break;
1445 	default:
1446 	  return false;
1447 	}
1448       return true;
1449     }
1450   else
1451     return false;
1452 }
1453 
gra_getmarkertypename(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1454 bool gra_getmarkertypename(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1455 {
1456 
1457   if (gra == 0 || outvalue == 0)
1458     return false;
1459 
1460   if (arglength == 1 && iid == -1)
1461     {
1462       switch(atoi((*argument)[0].c_str()))
1463 	{
1464 	case MARKER_NULL:
1465 	  outvalue->value->add("null");
1466 	  break;
1467 	case MARKER_SQUARE:
1468 	  outvalue->value->add("square");
1469 	  break;
1470 	case MARKER_TRIANGLE:
1471 	  outvalue->value->add("triangle");
1472 	  break;
1473 	case MARKER_REVTRIANGLE:
1474 	  outvalue->value->add("rev. triangle");
1475 	  break;
1476 	case MARKER_DIAMOND:
1477 	  outvalue->value->add("diamond");
1478 	  break;
1479 	case MARKER_CIRCLE:
1480 	  outvalue->value->add("circle");
1481 	  break;
1482 	case MARKER_CROSS:
1483 	  outvalue->value->add("cross");
1484 	  break;
1485 	case MARKER_DCROSS:
1486 	  outvalue->value->add("diag. cross");
1487 	  break;
1488 	case MARKER_VAREA:
1489 	  outvalue->value->add("vertical area");
1490 	  break;
1491 	case MARKER_HAREA:
1492 	  outvalue->value->add("horizontal area");
1493 	  break;
1494 	case MARKER_VBAR:
1495 	  outvalue->value->add("vertical bar");
1496 	  break;
1497 	case MARKER_HBAR:
1498 	  outvalue->value->add("horizontal bar");
1499 	  break;
1500 	case MARKER_VSTEP:
1501 	  outvalue->value->add("vertical step");
1502 	  break;
1503 	case MARKER_HSTEP:
1504 	  outvalue->value->add("horizontal step");
1505 	  break;
1506 	case MARKER_VBAR2:
1507 	  outvalue->value->add("vertical bar2");
1508 	  break;
1509 	case MARKER_HBAR2:
1510 	  outvalue->value->add("horizontal bar2");
1511 	  break;
1512 	default:
1513 	  return false;
1514 	}
1515       return true;
1516     }
1517   else
1518     return false;
1519 }
1520 
gra_gettickdirname(graph * gra,int arglength,int iid,buffarray * argument,tokenbuff * outvalue)1521 bool gra_gettickdirname(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue)
1522 {
1523 
1524   if (gra == 0 || outvalue == 0)
1525     return false;
1526 
1527   if (arglength == 2 && iid == -1)
1528     {
1529       switch(atoi((*argument)[0].c_str()))
1530 	{
1531 	case TICKPARITY_NULL:
1532 	  outvalue->value->add("null");
1533 	  break;
1534 	case TICKPARITY_PLUS:
1535 	  switch(atoi((*argument)[1].c_str()))
1536 	    {
1537 	    case 0:
1538 	    case 3:
1539 	      outvalue->value->add("out");
1540 	      break;
1541 	    case 1:
1542 	    case 2:
1543 	      outvalue->value->add("in");
1544 	      break;
1545 	    default:
1546 	      outvalue->value->add("");
1547 	      break;
1548 	    }
1549 	  break;
1550 	case TICKPARITY_MINUS:
1551 	  switch(atoi((*argument)[1].c_str()))
1552 	    {
1553 	    case 0:
1554 	    case 3:
1555 	      outvalue->value->add("in");
1556 	      break;
1557 	    case 1:
1558 	    case 2:
1559 	      outvalue->value->add("out");
1560 	      break;
1561 	    default:
1562 	      outvalue->value->add("");
1563 	      break;
1564 	    }
1565 	  break;
1566 	case TICKPARITY_BOTH:
1567 	  outvalue->value->add("both");
1568 	  break;
1569 	default:
1570 	  return false;
1571 	}
1572       return true;
1573     }
1574   else
1575     return false;
1576 }
1577 
1578 typedef struct grfuncs
1579 {
1580   char *function;
1581   bool (*func)(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue);
1582 }GRFUNCS;
1583 
1584 GRFUNCS grf[] = {
1585   {"paintall", gra_paintall},
1586   {"paint", gra_paint},
1587   {"preout", gra_preout},
1588   {"postout", gra_postout},
1589   {"drawpaper", gra_drawpaper},
1590   {"setbbox", gra_setbbox},
1591   {"gropen", gra_gropen},
1592   {"grappend", gra_grappend},
1593   {"grsave", gra_grsave},
1594   {"getindex", gra_getindex},
1595   {"delete", gra_delete},
1596   {"new", gra_new},
1597   {"flushselect", gra_flushselect},
1598   {"length", gra_length},
1599   {"top", gra_top},
1600   {"up", gra_up},
1601   {"down", gra_down},
1602   {"bottom", gra_bottom},
1603   {"copy", gra_copy},
1604   {"selectednumber", gra_selectednumber},
1605   {"getframetypename", gra_getframetypename},
1606   {"getlinestylename", gra_getlinestylename},
1607   {"getlinecapname", gra_getlinecapname},
1608   {"getlinejoinname", gra_getlinejoinname},
1609   {"getinterpolationname", gra_getinterpolationname},
1610   {"getfillstylename", gra_getfillstylename},
1611   {"getcolorname", gra_getcolorname},
1612   {"getscalingname", gra_getscalingname},
1613   {"getcommentlineactionname", gra_getcommentlineactionname},
1614   {"getlabelparityname", gra_getlabelparityname},
1615   {"getlabelcpparityname", gra_getlabelcpparityname},
1616   {"getlabelformatname", gra_getlabelformatname},
1617   {"getpartsname", gra_getpartsname},
1618   {"gettextfacename", gra_gettextfacename},
1619   {"gettextjpfacename", gra_gettextjpfacename},
1620   {"getlinearfitfunctionname", gra_getlinearfitfunctionname},
1621   {"getdatasearchpathname", gra_getdatasearchpathname},
1622   {"getmarkertypename", gra_getmarkertypename},
1623   {"gettickdirname", gra_gettickdirname},
1624   {0, 0}
1625 };
1626 
exec(std::string * function,buffarray * argument,tokenbuff * outvalue)1627 bool graph::exec(std::string* function, buffarray *argument, tokenbuff* outvalue)
1628 {
1629   std::string out, shrunk, str1, str2, str3;
1630   int iid, arglength;
1631   buffarray tempbuffarray;
1632 
1633   GRFUNCS *grfncs;
1634   int itemno;
1635   bool (*execfunc)(graph *gra, int arglength, int iid, buffarray *argument, tokenbuff* outvalue);
1636 
1637   outvalue->value->setbuff(0);
1638   if (topobject(function, &out, &iid) == true)
1639     {
1640       arglength = argument->getarraylength();
1641 
1642       // paint
1643       // transfer message to frame object
1644       if (out == std::string("frame"))
1645 	{
1646 	  if (shrinkobject(function, &shrunk))
1647 	    {
1648 	      if (iid < farray->getarraylength() && iid >= 0)
1649 		{
1650 		  if ((*farray)[iid].exec(&shrunk, argument, outvalue))
1651 		    return true;
1652 		  else
1653 		    return false;
1654 		}
1655 	      else if (iid == -2)  // only current frame
1656 		{
1657 		  if (currentframe >= farray->getarraylength() || currentframe < 0)
1658 		    return false;
1659 
1660 		  if ((*farray)[currentframe].exec(&shrunk, argument, outvalue))
1661 		    return true;
1662 		  else
1663 		    return false;
1664 		}
1665 	      // selected
1666 	      else if (iid == -3)
1667 		{
1668 		  for (int i = 0; i < farray->getarraylength(); i++)
1669 		    {
1670 		      if ((*farray)[i].selected)
1671 			{
1672 			  if (!(*farray)[i].exec(&shrunk, argument, outvalue))
1673 			    return false;
1674 			}
1675 		    }
1676 		  return true;
1677 		}
1678 	      // all
1679 	      else if (iid == -4)
1680 		{
1681 		  for (int i = 0; i < farray->getarraylength(); i++)
1682 		    {
1683 		      if (!(*farray)[i].exec(&shrunk, argument, outvalue))
1684 			return false;
1685 		    }
1686 		  return true;
1687 		}
1688 	      // first selected
1689 	      else if (iid == -5)
1690 		{
1691 		  for (int i = 0; i < farray->getarraylength(); i++)
1692 		    {
1693 		      if ((*farray)[i].selected)
1694 			{
1695 			  if ((*farray)[i].exec(&shrunk, argument, outvalue))
1696 			    return true;
1697 			  else
1698 			    return false;
1699 			}
1700 		    }
1701 		  return true;
1702 		}
1703 	      else
1704 		return false;
1705 	    }
1706 	  else
1707 	    return false;
1708 	}
1709       // transfer message to gbuffer
1710       else if (out == std::string("buffer"))
1711 	{
1712 	  if (shrinkobject(function, &shrunk))
1713 	    {
1714 	      if (gbuffer->exec(&shrunk, argument, outvalue))
1715 		return true;
1716 	      else
1717 		return false;
1718 	    }
1719 	  else
1720 	    return false;
1721 	}
1722       // transfer message to init
1723       else if (out == std::string("init"))
1724 	{
1725 	  if (shrinkobject(function, &shrunk))
1726 	    {
1727 	      if (init->exec(&shrunk, argument, outvalue))
1728 		return true;
1729 	      else
1730 		return false;
1731 	    }
1732 	  else
1733 	    return false;
1734 	}
1735       // else
1736       else
1737 	{
1738 	  grfncs = grf;
1739 	  for (; grfncs->function; grfncs++)
1740 	    {
1741 	    }
1742 	  itemno = grfncs - grf;
1743 	  for (int i = 0; i < itemno; i++)
1744 	    {
1745 	      if (strcmp(out.c_str(), grf[i].function) == 0)
1746 		{
1747 		  execfunc = grf[i].func;
1748 		  return execfunc(this, arglength, iid, argument, outvalue);
1749 		}
1750 	    }
1751 	  return false;
1752 	}
1753     }
1754   else
1755     return false;
1756 
1757   return true;
1758 }
1759 
setframeid(int arrayno)1760 bool graph::setframeid(int arrayno)
1761 {
1762   bool exist = false;
1763   for (int i = 0; i <= farray->getarraylength(); i++)
1764     {
1765       exist = false;
1766       for (int j = 0; j < farray->getarraylength(); j++)
1767 	{
1768 	  if ((*farray)[j].id == i && j != arrayno)
1769 	    exist = true;
1770 	}
1771 
1772       if (exist == false)
1773 	{
1774 	  (*farray)[arrayno].id = i;
1775 	  return true;
1776 	}
1777     }
1778   return false;
1779 }
1780 
appendgraph(FILE * fp)1781 bool graph::appendgraph(FILE *fp)
1782 {
1783   int no, frameno = 0, dataid = 0;
1784   char stemp[10000], stemp1[1024];
1785   std::string str;
1786   char *p;
1787   frame *fr = 0;
1788   data *dat = 0;
1789   char datalabel[10];
1790   std::string filen, outfilen;
1791   FILE *out;
1792   int readversion;
1793 
1794   // version
1795   if (getnextline(stemp, sizeof(stemp), fp))
1796   {
1797     if (nextitem(stemp, &str) != 0)
1798       readversion = atoi(str.c_str());
1799     else
1800       return false;
1801   }
1802   else
1803     return false;
1804 
1805   // graph filename
1806   if (getnextline(stemp, sizeof(stemp), fp))
1807   {
1808     if (gettxt(stemp, &str))
1809       {
1810         getcwd(stemp1, sizeof(stemp1));
1811         strcpy(stemp, tofilename((char *)str.c_str()));
1812         strcat(stemp1, "/"); strcat(stemp1, stemp);
1813         strcpy(graphname, stemp1);
1814 //        strncpy(graphname, str.c_str(), 1024);
1815       }
1816     else
1817       return false;
1818   }
1819   else
1820     return false;
1821 
1822   while (getnextline(stemp, sizeof(stemp), fp))
1823     {
1824       if (nextitem(stemp, &str))
1825 	{
1826 	  strncpy(datalabel, str.c_str(), 4);
1827 	  datalabel[4] = 0;
1828 
1829 	  if (str == std::string("[frame]"))
1830 	    {
1831 	      farray->add(new frame);
1832 	      no = farray->getarraylength() - 1;
1833 	      frameno = no;
1834 	      fr = &(*farray)[no];
1835 	      fr->parent = (void *)this;
1836 	      fr->readframe(fp);
1837 	      setframeid(no);
1838 	      fr->axarray->setbuff(0);
1839 	    }
1840 	  else if (str == std::string("[axis]"))
1841 	    {
1842 	      if (fr != 0)
1843 		{
1844 		  fr->axarray->add(new axis);
1845 		  no = fr->axarray->getarraylength() - 1;
1846 		  (*fr->axarray)[no].parent = (void *)fr;
1847 		  fr->setaxisid(fr->axarray->getarraylength() - 1);
1848 		  (*fr->axarray)[no].readaxis(fp);
1849 		}
1850 	    }
1851 	  else if (str == std::string("[parts]"))
1852 	    {
1853 	      if (fr != 0)
1854 		{
1855 		  fr->parray->add(new parts);
1856 		  no = fr->parray->getarraylength() - 1;
1857 		  (*fr->parray)[no].parent = (void *)fr;
1858 		  fr->setpartsid(fr->parray->getarraylength() - 1);
1859 		  (*fr->parray)[no].readparts(fp);
1860 		}
1861 	    }
1862 	  else if (str == std::string("[data]"))
1863 	    {
1864 	      if (fr != 0)
1865 		{
1866 		  fr->darray->add(new data);
1867 		  no = fr->darray->getarraylength() - 1;
1868 		  dat = &(*fr->darray)[no];
1869 		  dat->parent = (void *)fr;
1870 		  fr->setdataid(fr->darray->getarraylength() - 1);
1871 		  dat->readdata(fp);
1872 		  dataid = dat->id;
1873 		  dat->restoreabspath(graphname);
1874 		}
1875 	    }
1876 	  else if (strcmp(datalabel, "sod[") == 0)
1877 	    {
1878 	      filen = std::string("");
1879 	      p = stemp + 4;
1880 	      while (*p != 0 && *p != ']')
1881 		{
1882 		  stemp1[0] = *p; stemp1[1] = 0;
1883 		  filen += std::string(stemp1);
1884 		  p++;
1885 		}
1886 	      if (*p == 0)
1887 		return false;
1888 
1889 	      if (readversion <= 10002)
1890 		{
1891 		  for (int i = 0; i < fr->darray->getarraylength(); i++)
1892 		    {
1893 		      dat = &(*fr->darray)[i];
1894 		      if (strcmp(filen.c_str(), dat->filename) == 0)
1895 			{
1896 			  outfilen = std::string(tmppath);
1897 			  outfilen += std::string("/") + std::string(pid);
1898 			  sprintf(stemp1, "%d_", frameno);
1899 			  outfilen += std::string(stemp1);
1900 			  sprintf(stemp1, "%d_", dat->id);
1901 			  outfilen += std::string(stemp1);
1902 			  outfilen += filen;
1903 			  if ((out = fopen(outfilen.c_str(), "w")) == 0)
1904 			    return false;
1905 			  while(topazfgets(stemp, sizeof(stemp), fp) != NULL)
1906 			    {
1907 			      if (strcmp(stemp, "eod\n") != 0)
1908 				fputs(stemp, out);
1909 			      else
1910 				break;
1911 			    }
1912 			  fclose(out);
1913 			}
1914 		    }
1915 		}
1916 	      else
1917 		{
1918 		  outfilen = std::string(tmppath);
1919 		  outfilen += std::string("/") + std::string(pid);
1920 		  sprintf(stemp1, "%d_", frameno);
1921 		  outfilen += std::string(stemp1);
1922 		  sprintf(stemp1, "%d_", dataid);
1923 		  outfilen += std::string(stemp1);
1924 		  outfilen += filen;
1925 		  if ((out = fopen(outfilen.c_str(), "w")) == 0)
1926 		    return false;
1927 		  while(topazfgets(stemp, sizeof(stemp), fp) != NULL)
1928 		    {
1929 		      if (strcmp(stemp, "eod\n") != 0)
1930 			fputs(stemp, out);
1931 		      else
1932 			break;
1933 		    }
1934 		  fclose(out);
1935 		}
1936 	    }
1937 	}
1938       else
1939 	return false;
1940     }
1941 
1942   for (int i = 0; i < farray->getarraylength(); i++)
1943     {
1944       fr = &(*farray)[i];
1945       for (int j = 0; j < fr->darray->getarraylength(); j++)
1946 	{
1947 	  dat = &(*fr->darray)[j];
1948 	  if (dat->isfiledata)
1949 	    dat->loaddata();
1950 	  else
1951 	    {
1952 	      if (!genxdata(dat->m_start, dat->m_end, dat->m_div, dat->m_scaling, dat->x, dat->y))
1953 		{
1954 		  message("Error: cannot generate curve!!\n");
1955 		  return false;
1956 		}
1957 	    }
1958 	}
1959     }
1960 
1961   return true;
1962 }
1963 
readgraph(FILE * fp)1964 bool graph::readgraph(FILE *fp)
1965 {
1966   bool flag;
1967   farray->setbuff(0);
1968   currentframe = 0;
1969   flag = appendgraph(fp);
1970   showsepwin();
1971   return flag;
1972 }
1973 
writegraph(FILE * fp)1974 bool graph::writegraph(FILE *fp)
1975 {
1976   frame *fr = 0;
1977   data *dat = 0;
1978   char file[100];
1979 
1980   fprintf(fp, "# topaz graph format\n");
1981   fprintf(fp, "%d\n", version);
1982   fprintf(fp, "\"%s\"\n", graphname);
1983 
1984   for (int i = 0; i < farray->getarraylength(); i++)
1985     {
1986       fr = &(*farray)[i];
1987 
1988       //frame
1989       fr->writeframe(fp);
1990 
1991       // axis
1992       for (int j = 0; j < fr->axarray->getarraylength(); j++)
1993 	(*fr->axarray)[j].writeaxis(fp);
1994 
1995       // parts
1996       for (int j = 0; j < fr->parray->getarraylength(); j++)
1997 	(*fr->parray)[j].writeparts(fp);
1998 
1999       // if non-withdata, check the existence of non-virgin data
2000       if (!checkfileexist())
2001 	  return false;
2002 
2003       // if withdata and virgin, copy original files to buffer
2004       if ((*farray)[i].withdata)
2005 	{
2006 	  for (int k = 0; k < (*farray)[i].darray->getarraylength(); k++)
2007 	    {
2008 	      dat = &(*fr->darray)[k];
2009 	      if (dat->virgin)
2010 		{
2011 		  loadtobuff(dat->filename, fr->id, dat->id);
2012 		  strcpy(file, toshortfilename(dat->filename));
2013 		  strcpy(dat->filename, file);
2014 		  dat->virgin = false;
2015 		}
2016 	    }
2017 	}
2018 
2019       // change data filename (abs->ref path)
2020       for (int k = 0; k < (*farray)[i].darray->getarraylength(); k++)
2021 	{
2022 	  dat = &(*fr->darray)[k];
2023 	  dat->setrefpath(graphname);
2024 	}
2025 
2026       for (int j = 0; j < fr->darray->getarraylength(); j++)
2027 	{
2028 	  dat = &(*fr->darray)[j];
2029 	  dat->writedata(fp);
2030 
2031 	  if ((*farray)[i].withdata)
2032 	    {
2033 	      if (dat->isfiledata)
2034 		    dat->appendoriginaldata(fp, dat->id);
2035 	    }
2036 	}
2037     }
2038 
2039   showsepwin();
2040   return true;
2041 }
2042 
checkfileexist()2043 bool graph::checkfileexist()
2044 {
2045   frame *fr;
2046   data  *dat;
2047   char stemp[1000];
2048   FILE *fp;
2049 
2050   for (int i = 0; i < farray->getarraylength(); i++)
2051     {
2052       fr = &(*farray)[i];
2053       if (!fr->withdata)
2054 	{
2055 	  for (int j = 0; j < fr->darray->getarraylength(); j++)
2056 	    {
2057 	      dat = &(*fr->darray)[j];
2058 	      if (dat->virgin && dat->isfiledata)
2059 //	      if (dat->virgin)
2060 		{
2061 		  if ((fp = fopen(dat->filename, "r")) == NULL)
2062 		    {
2063 		      message("Error!!: Cannot refer to original file\n");
2064 		      sprintf(stemp, "frame[%d]->data[%d]\n", i, j);
2065 		      message("Could not save correctly!!\n");
2066 		      message(stemp);
2067 		      return false;
2068 		    }
2069 		  else
2070 		    fclose(fp);
2071 		}
2072 	    }
2073 	}
2074     }
2075   return true;
2076 }
2077 
loadtobuff(char * infile,int frameid,int dataid)2078 bool graph::loadtobuff(char *infile, int frameid, int dataid)
2079 {
2080   FILE *in, *out;
2081   char outfile[1000];
2082   char buff[10000], stemp[100];
2083 
2084   strcpy(outfile, tmppath);
2085   strcat(outfile, "/");
2086   strcat(outfile, pid);
2087   sprintf(stemp, "%d_", frameid);
2088   strcat(outfile, stemp);
2089   sprintf(stemp, "%d_", dataid);
2090   strcat(outfile, stemp);
2091   strcat(outfile, toshortfilename(infile));
2092 
2093   if ((in = fopen(infile, "r")) == NULL)
2094       return false;
2095   if ((out = fopen(outfile, "w")) == NULL)
2096     {
2097       fclose(in);
2098       return false;
2099     }
2100   while(topazfgets(buff, sizeof(buff), in) != NULL)
2101     {
2102       if (strlen(buff) > 0)
2103 	{
2104 	  if (buff[strlen(buff) - 1] == '\n')
2105 	    {
2106 	      if (strlen(buff) > 1 && buff[strlen(buff) - 2] == '\r')
2107 		{
2108 		  buff[strlen(buff) - 2] = '\n';
2109 		  buff[strlen(buff) - 1] = '\0';
2110 		}
2111 	    }
2112 	  fputs(buff, out);
2113 	}
2114     }
2115 
2116   fclose(in);
2117   fclose(out);
2118   return true;
2119 }
2120 
flushtmpfiles()2121 void graph::flushtmpfiles()
2122 {
2123   DIR *dp;
2124   struct dirent *entry;
2125   std::string str1;
2126   fileentarray *filearray;
2127   std::string delfiles;
2128   char stemp[100];
2129 
2130   strcpy(stemp, "^");
2131   strcat(stemp, pid);
2132 
2133   filearray = new fileentarray;
2134   if (filearray == 0)
2135     return;
2136 
2137   if ((dp = opendir(tmppath)) == NULL)
2138     return;
2139 
2140   while ((entry = readdir(dp)) != NULL)
2141     {
2142       str1 = std::string(entry->d_name);
2143       if (simplematch(str1.c_str(), stemp))
2144 	{
2145 	  filearray->add(new fileentry);
2146 	  strcpy((*filearray)[filearray->getarraylength() - 1].filename, entry->d_name);
2147 	}
2148     }
2149   closedir (dp);
2150 
2151 
2152   for (int i = 0; i < filearray->getarraylength(); i++)
2153     {
2154       delfiles = std::string(tmppath) + std::string("/") + std::string((*filearray)[i].filename);
2155       unlink(delfiles.c_str());
2156     }
2157   delete filearray;
2158 }
2159 
drawpaper(bool flag,FILE * f)2160 bool graph::drawpaper(bool flag, FILE *f)
2161 {
2162   plinestyle(flag, f, 0, 0, 0, 0);
2163   psetforecolor(flag, f, 0, 0, 0);
2164   pbeginpath(flag, f);
2165   pmoveto(flag, f, 0, 0);
2166   plineto(flag, f, papersize.x, 0);
2167   plineto(flag, f, papersize.x, papersize.y);
2168   plineto(flag, f, 0, papersize.y);
2169   plineto(flag, f, 0, 0);
2170   pstroke(flag, f);
2171   return true;
2172 }
2173 
2174 
scale(int x)2175 int graph::scale(int x)
2176 {
2177   return x;
2178 }
2179 
versionstring(char * s)2180 void graph::versionstring(char *s)
2181 {
2182   int majorv, minorv, betav;
2183   char majorstr[100], minorstr[100], betastr[100];
2184 
2185   majorv = version / 10000;
2186   minorv = (version - 10000 * majorv) / 100;
2187   betav = version - 10000 * majorv - 100 * minorv;
2188 
2189   sprintf(majorstr, "%d.", majorv);
2190   sprintf(minorstr, "%02d", minorv);
2191 
2192   if (betav != 99)
2193     sprintf(betastr, " beta %d ", betav);
2194   else
2195     strcpy(betastr, "");
2196 
2197   strcpy(s, majorstr);
2198   strcat(s, minorstr);
2199   strcat(s, betastr);
2200 }
2201 
2202 
2203 
2204