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