| 1 | /*
|
|---|
| 2 | * $Source: /tmp_mnt/n/fs/grad1/jsp/src/jgraph/RCS/edit.c,v $
|
|---|
| 3 | * $Revision: 8.3 $
|
|---|
| 4 | * $Date: 92/11/30 11:42:12 $
|
|---|
| 5 | * $Author: jsp $
|
|---|
| 6 | */
|
|---|
| 7 |
|
|---|
| 8 |
|
|---|
| 9 | #include <stdio.h>
|
|---|
| 10 |
|
|---|
| 11 | #include "jgraph.h"
|
|---|
| 12 |
|
|---|
| 13 | #define MAX(a,b) ((a > b) ? a : b)
|
|---|
| 14 | #define MIN(a,b) ((a < b) ? a : b)
|
|---|
| 15 |
|
|---|
| 16 | edit_label(l)
|
|---|
| 17 | Label l;
|
|---|
| 18 | {
|
|---|
| 19 | char *txt, inp_str[80];
|
|---|
| 20 | float f;
|
|---|
| 21 | int i;
|
|---|
| 22 |
|
|---|
| 23 | while ( getstring(inp_str) ) {
|
|---|
| 24 | if (strcmp(inp_str, ":") == 0) {
|
|---|
| 25 | if ((txt = getlabel()) == CNULL) return;
|
|---|
| 26 | l->label = txt;
|
|---|
| 27 | } else if (strcmp(inp_str, "x") == 0) {
|
|---|
| 28 | if (!getfloat(&f)) rejecttoken(); else l->x = f;
|
|---|
| 29 | } else if (strcmp(inp_str, "y") == 0) {
|
|---|
| 30 | if (!getfloat(&f)) rejecttoken(); else l->y = f;
|
|---|
| 31 | } else if (strcmp(inp_str, "fontsize") == 0) {
|
|---|
| 32 | if (!getfloat(&f)) rejecttoken(); else l->fontsize = f;
|
|---|
| 33 | } else if (strcmp(inp_str, "linesep") == 0) {
|
|---|
| 34 | if (!getfloat(&f)) rejecttoken(); else l->linesep = f;
|
|---|
| 35 | } else if (strcmp(inp_str, "hjl") == 0) {
|
|---|
| 36 | l->hj = 'l';
|
|---|
| 37 | } else if (strcmp(inp_str, "hjc") == 0) {
|
|---|
| 38 | l->hj = 'c';
|
|---|
| 39 | } else if (strcmp(inp_str, "hjr") == 0) {
|
|---|
| 40 | l->hj = 'r';
|
|---|
| 41 | } else if (strcmp(inp_str, "vjc") == 0) {
|
|---|
| 42 | l->vj = 'c';
|
|---|
| 43 | } else if (strcmp(inp_str, "vjt") == 0) {
|
|---|
| 44 | l->vj = 't';
|
|---|
| 45 | } else if (strcmp(inp_str, "vjb") == 0) {
|
|---|
| 46 | l->vj = 'b';
|
|---|
| 47 | } else if (strcmp(inp_str, "font") == 0) {
|
|---|
| 48 | if (!getstring(inp_str)) return;
|
|---|
| 49 | txt = (char *) malloc (sizeof(char)*strlen(inp_str)+2);
|
|---|
| 50 | strcpy(txt, inp_str);
|
|---|
| 51 | l->font = txt;
|
|---|
| 52 | } else if (strcmp(inp_str, "rotate") == 0) {
|
|---|
| 53 | if (!getfloat(&f)) rejecttoken(); else l->rotate = f;
|
|---|
| 54 | } else if (strcmp(inp_str, "lgray") == 0) {
|
|---|
| 55 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 56 | l->graytype = 'g';
|
|---|
| 57 | l->gray[0] = f;
|
|---|
| 58 | }
|
|---|
| 59 | } else if (strcmp(inp_str, "lcolor") == 0) {
|
|---|
| 60 | l->graytype = 'c';
|
|---|
| 61 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 62 | if(!getfloat(&f)) {
|
|---|
| 63 | rejecttoken();
|
|---|
| 64 | l->graytype = 'n';
|
|---|
| 65 | break ;
|
|---|
| 66 | } else l->gray[i] = f ;
|
|---|
| 67 | }
|
|---|
| 68 | } else {
|
|---|
| 69 | rejecttoken();
|
|---|
| 70 | return;
|
|---|
| 71 | }
|
|---|
| 72 | }
|
|---|
| 73 | }
|
|---|
| 74 |
|
|---|
| 75 | copy_curve(c1, c2) /* Copies curve c2 to c1 */
|
|---|
| 76 | Curve c1, c2;
|
|---|
| 77 | {
|
|---|
| 78 | Flist f, newf;
|
|---|
| 79 | Point p, newp;
|
|---|
| 80 |
|
|---|
| 81 | copy_label(c1->l, c2->l);
|
|---|
| 82 | copy_label(c1->lmark, c2->lmark);
|
|---|
| 83 | c1->l->label = CNULL;
|
|---|
| 84 | c1->clip = c2->clip;
|
|---|
| 85 | for (f = first(c2->gen_linetype);
|
|---|
| 86 | f != nil(c2->gen_linetype);
|
|---|
| 87 | f = next(f)) {
|
|---|
| 88 | newf = (Flist) get_node(c1->gen_linetype);
|
|---|
| 89 | newf->f = f->f;
|
|---|
| 90 | insert(newf, c1->gen_linetype);
|
|---|
| 91 | }
|
|---|
| 92 | c1->pattern = c2->pattern;
|
|---|
| 93 | c1->apattern = c2->apattern;
|
|---|
| 94 | c1->ppattern = c2->ppattern;
|
|---|
| 95 | c1->parg = c2->parg;
|
|---|
| 96 | c1->aparg = c2->aparg;
|
|---|
| 97 | c1->pparg = c2->pparg;
|
|---|
| 98 | c1->marktype = c2->marktype;
|
|---|
| 99 | c1->linetype = c2->linetype;
|
|---|
| 100 | c1->linethick = c2->linethick;
|
|---|
| 101 | c1->marksize[0] = c2->marksize[0];
|
|---|
| 102 | c1->marksize[1] = c2->marksize[1];
|
|---|
| 103 | c1->mrotate = c2->mrotate;
|
|---|
| 104 | for (p = first(c2->general_marks);
|
|---|
| 105 | p != nil(c2->general_marks);
|
|---|
| 106 | p = next(p)) {
|
|---|
| 107 | newp = (Point) get_node(c1->general_marks);
|
|---|
| 108 | newp->x = p->x;
|
|---|
| 109 | newp->y = p->y;
|
|---|
| 110 | insert(newp, c1->general_marks);
|
|---|
| 111 | }
|
|---|
| 112 | c1->graytype = c2->graytype;
|
|---|
| 113 | c1->gray[0] = c2->gray[0];
|
|---|
| 114 | c1->gray[1] = c2->gray[1];
|
|---|
| 115 | c1->gray[2] = c2->gray[2];
|
|---|
| 116 | c1->filltype = c2->filltype;
|
|---|
| 117 | c1->fill[0] = c2->fill[0];
|
|---|
| 118 | c1->fill[1] = c2->fill[1];
|
|---|
| 119 | c1->fill[2] = c2->fill[2];
|
|---|
| 120 | c1->poly = c2->poly;
|
|---|
| 121 | c1->pfilltype = c2->pfilltype;
|
|---|
| 122 | c1->pfill[0] = c2->pfill[0];
|
|---|
| 123 | c1->pfill[1] = c2->pfill[1];
|
|---|
| 124 | c1->pfill[2] = c2->pfill[2];
|
|---|
| 125 | c1->afilltype = c2->afilltype;
|
|---|
| 126 | c1->afill[0] = c2->afill[0];
|
|---|
| 127 | c1->afill[1] = c2->afill[1];
|
|---|
| 128 | c1->afill[2] = c2->afill[2];
|
|---|
| 129 | c1->postscript = c2->postscript;
|
|---|
| 130 | c1->postfile = c2->postfile;
|
|---|
| 131 | c1->eps = c2->eps;
|
|---|
| 132 | c1->rarrow = c2->rarrow;
|
|---|
| 133 | c1->larrow = c2->larrow;
|
|---|
| 134 | c1->rarrows = c2->rarrows;
|
|---|
| 135 | c1->larrows = c2->larrows;
|
|---|
| 136 | c1->asize[0] = c2->asize[0];
|
|---|
| 137 | c1->asize[1] = c2->asize[1];
|
|---|
| 138 | c1->bezier = c2->bezier;
|
|---|
| 139 | }
|
|---|
| 140 |
|
|---|
| 141 | copy_label(l1, l2) /* Copies label l2 to l1 */
|
|---|
| 142 | Label l1, l2;
|
|---|
| 143 | {
|
|---|
| 144 | l1->label = l2->label;
|
|---|
| 145 | l1->x = l2->x;
|
|---|
| 146 | l1->y = l2->y;
|
|---|
| 147 | l1->rotate = l2->rotate;
|
|---|
| 148 | l1->font = l2->font;
|
|---|
| 149 | l1->fontsize = l2->fontsize;
|
|---|
| 150 | l1->hj = l2->hj;
|
|---|
| 151 | l1->vj = l2->vj;
|
|---|
| 152 | l1->graytype = l2->graytype;
|
|---|
| 153 | l1->gray[0] = l2->gray[0];
|
|---|
| 154 | l1->gray[1] = l2->gray[1];
|
|---|
| 155 | l1->gray[2] = l2->gray[2];
|
|---|
| 156 | l1->linesep = l2->linesep;
|
|---|
| 157 | }
|
|---|
| 158 |
|
|---|
| 159 | copy_axis(a1, a2) /* Copies axis a2 to a1 */
|
|---|
| 160 | Axis a1, a2;
|
|---|
| 161 | {
|
|---|
| 162 | copy_label(a1->label, a2->label);
|
|---|
| 163 | copy_label(a1->hl, a2->hl);
|
|---|
| 164 | a1->max = a2->max;
|
|---|
| 165 | a1->min = a2->min;
|
|---|
| 166 | a1->pmax = a2->pmax;
|
|---|
| 167 | a1->pmin = a2->pmin;
|
|---|
| 168 | a1->size = a2->size;
|
|---|
| 169 | a1->hash_interval = a2->hash_interval;
|
|---|
| 170 | a1->hash_start = a2->hash_start;
|
|---|
| 171 | a1->log_base = a2->log_base;
|
|---|
| 172 | a1->draw_hash_marks_at = a2->draw_hash_marks_at;
|
|---|
| 173 | a1->draw_hash_labels_at = a2->draw_hash_labels_at;
|
|---|
| 174 | a1->draw_at = a2->draw_at;
|
|---|
| 175 | a1->draw_hash_labels = a2->draw_hash_labels;
|
|---|
| 176 | a1->draw_axis_line = a2->draw_axis_line;
|
|---|
| 177 | a1->draw_hash_marks = a2->draw_hash_marks;
|
|---|
| 178 | a1->draw_axis_label = a2->draw_axis_label;
|
|---|
| 179 | a1->auto_hash_labels = a2->auto_hash_labels;
|
|---|
| 180 | a1->auto_hash_marks = a2->auto_hash_marks;
|
|---|
| 181 | a1->minor_hashes = a2->minor_hashes;
|
|---|
| 182 | a1->hash_scale = a2->hash_scale;
|
|---|
| 183 | a1->hash_format = a2->hash_format;
|
|---|
| 184 | a1->graytype = a2->graytype;
|
|---|
| 185 | a1->gray[0] = a2->gray[0];
|
|---|
| 186 | a1->gray[1] = a2->gray[1];
|
|---|
| 187 | a1->gray[2] = a2->gray[2];
|
|---|
| 188 | a1->mgr_graytype = a2->mgr_graytype;
|
|---|
| 189 | a1->mgr_gray[0] = a2->mgr_gray[0];
|
|---|
| 190 | a1->mgr_gray[1] = a2->mgr_gray[1];
|
|---|
| 191 | a1->mgr_gray[2] = a2->mgr_gray[2];
|
|---|
| 192 | a1->gr_graytype = a2->gr_graytype;
|
|---|
| 193 | a1->gr_gray[0] = a2->gr_gray[0];
|
|---|
| 194 | a1->gr_gray[1] = a2->gr_gray[1];
|
|---|
| 195 | a1->gr_gray[2] = a2->gr_gray[2];
|
|---|
| 196 | a1->grid_lines = a2->grid_lines;
|
|---|
| 197 | a1->mgrid_lines = a2->mgrid_lines;
|
|---|
| 198 | a1->precision = a2->precision;
|
|---|
| 199 | a1->start_given = a2->start_given;
|
|---|
| 200 | a1->is_lg = a2->is_lg;
|
|---|
| 201 | a1->is_x = a2->is_x;
|
|---|
| 202 | }
|
|---|
| 203 |
|
|---|
| 204 | Curve do_copy_curve(g, gs, all_gs)
|
|---|
| 205 | Graph g;
|
|---|
| 206 | Graphs gs;
|
|---|
| 207 | Graphs all_gs;
|
|---|
| 208 | {
|
|---|
| 209 | Curve lastc, newc;
|
|---|
| 210 | Graph oldg;
|
|---|
| 211 | Graphs oldgs;
|
|---|
| 212 | int num;
|
|---|
| 213 |
|
|---|
| 214 | if (!getint(&num)) {
|
|---|
| 215 | rejecttoken();
|
|---|
| 216 | oldg = g;
|
|---|
| 217 | oldgs = gs;
|
|---|
| 218 | while(gs != nil(all_gs)) {
|
|---|
| 219 | if (gs != oldgs) g = last(gs->g);
|
|---|
| 220 | while(g != nil(gs->g)) {
|
|---|
| 221 | if (first(g->curves) == nil(g->curves)) g = prev(g);
|
|---|
| 222 | else {
|
|---|
| 223 | lastc = last(g->curves);
|
|---|
| 224 | if (first(oldg->curves) == nil(oldg->curves))
|
|---|
| 225 | newc = new_curve(oldg->curves, 0);
|
|---|
| 226 | else newc = new_curve(oldg->curves, last(oldg->curves)->num + 1);
|
|---|
| 227 | copy_curve(newc, lastc);
|
|---|
| 228 | return newc;
|
|---|
| 229 | }
|
|---|
| 230 | }
|
|---|
| 231 | gs = prev(gs);
|
|---|
| 232 | }
|
|---|
| 233 | error_header();
|
|---|
| 234 | fprintf(stderr, "Cannot perform copycurve on first curve\n");
|
|---|
| 235 | exit(1);
|
|---|
| 236 | } else {
|
|---|
| 237 | if (first(g->curves) == nil(g->curves))
|
|---|
| 238 | newc = new_curve(g->curves, 0);
|
|---|
| 239 | else newc = new_curve(g->curves, last(g->curves)->num + 1);
|
|---|
| 240 | lastc = g->curves;
|
|---|
| 241 | while(1) {
|
|---|
| 242 | lastc = prev(lastc);
|
|---|
| 243 | if (lastc == nil(g->curves) || lastc->num < num) {
|
|---|
| 244 | error_header();
|
|---|
| 245 | fprintf(stderr, "copycurve: curve #%d not found\n", num);
|
|---|
| 246 | exit(1);
|
|---|
| 247 | }
|
|---|
| 248 | if (lastc->num == num) {
|
|---|
| 249 | copy_curve(newc, lastc);
|
|---|
| 250 | return newc;
|
|---|
| 251 | }
|
|---|
| 252 | }
|
|---|
| 253 | }
|
|---|
| 254 | return newc; /* To shut lint up */
|
|---|
| 255 | }
|
|---|
| 256 |
|
|---|
| 257 | Label do_copy_string(g, gs, all_gs)
|
|---|
| 258 | Graph g;
|
|---|
| 259 | Graphs gs;
|
|---|
| 260 | Graphs all_gs;
|
|---|
| 261 | {
|
|---|
| 262 | String lastl, newl;
|
|---|
| 263 | Graph oldg;
|
|---|
| 264 | Graphs oldgs;
|
|---|
| 265 | int num;
|
|---|
| 266 |
|
|---|
| 267 | if (!getint(&num)) {
|
|---|
| 268 | rejecttoken();
|
|---|
| 269 | oldgs = gs;
|
|---|
| 270 | oldg = g;
|
|---|
| 271 | while(gs != nil(all_gs)) {
|
|---|
| 272 | if (gs != oldgs) g = last(gs->g);
|
|---|
| 273 | while(g != nil(gs->g)) {
|
|---|
| 274 | if (first(g->strings) == nil(g->strings)) g = prev(g);
|
|---|
| 275 | else {
|
|---|
| 276 | lastl = last(g->strings);
|
|---|
| 277 | if (first(oldg->strings) == nil(oldg->strings))
|
|---|
| 278 | newl = new_string(oldg->strings, 0);
|
|---|
| 279 | else newl = new_string(oldg->strings, last(oldg->strings)->num + 1);
|
|---|
| 280 | copy_label(newl->s, lastl->s);
|
|---|
| 281 | return newl->s;
|
|---|
| 282 | }
|
|---|
| 283 | }
|
|---|
| 284 | gs = prev(gs);
|
|---|
| 285 | }
|
|---|
| 286 | error_header();
|
|---|
| 287 | fprintf(stderr, "Cannot perform copystring on first string\n");
|
|---|
| 288 | exit(1);
|
|---|
| 289 | return newl->s; /* To shut lint up */
|
|---|
| 290 | } else {
|
|---|
| 291 | if (first(g->strings) == nil(g->strings))
|
|---|
| 292 | newl = new_string(g->strings, 0);
|
|---|
| 293 | else newl = new_string(g->strings, last(g->strings)->num + 1);
|
|---|
| 294 | lastl = g->strings;
|
|---|
| 295 | while(1) {
|
|---|
| 296 | lastl = prev(lastl);
|
|---|
| 297 | if (lastl == nil(g->strings) || lastl->num < num) {
|
|---|
| 298 | error_header();
|
|---|
| 299 | fprintf(stderr, "copystring: string #%d not found\n", num);
|
|---|
| 300 | exit(1);
|
|---|
| 301 | }
|
|---|
| 302 | if (lastl->num == num) {
|
|---|
| 303 | copy_label(newl->s, lastl->s);
|
|---|
| 304 | return newl->s;
|
|---|
| 305 | }
|
|---|
| 306 | }
|
|---|
| 307 | }
|
|---|
| 308 | }
|
|---|
| 309 |
|
|---|
| 310 | Graph last_graph(g, gs, all_gs)
|
|---|
| 311 | Graph g;
|
|---|
| 312 | Graphs gs;
|
|---|
| 313 | Graphs all_gs;
|
|---|
| 314 | {
|
|---|
| 315 | Graph lastg;
|
|---|
| 316 |
|
|---|
| 317 |
|
|---|
| 318 | lastg = prev(g);
|
|---|
| 319 | while(lastg == nil(gs->g)) {
|
|---|
| 320 | if (prev(gs) == nil(all_gs)) {
|
|---|
| 321 | error_header();
|
|---|
| 322 | fprintf(stderr, "First graph cannot inherit axes\n");
|
|---|
| 323 | exit(1);
|
|---|
| 324 | } else {
|
|---|
| 325 | gs = prev(gs);
|
|---|
| 326 | lastg = last(gs->g);
|
|---|
| 327 | }
|
|---|
| 328 | }
|
|---|
| 329 | return lastg;
|
|---|
| 330 | }
|
|---|
| 331 |
|
|---|
| 332 | copy_legend(l1, l2)
|
|---|
| 333 | Legend l1, l2;
|
|---|
| 334 | {
|
|---|
| 335 | l1->linelength = l2->linelength;
|
|---|
| 336 | l1->linebreak = l2->linebreak;
|
|---|
| 337 | l1->midspace = l2->midspace;
|
|---|
| 338 | l1->type = l2->type;
|
|---|
| 339 | copy_label(l1->l, l2->l);
|
|---|
| 340 | }
|
|---|
| 341 |
|
|---|
| 342 | inherit_axes(g, lastg)
|
|---|
| 343 | Graph g;
|
|---|
| 344 | Graph lastg;
|
|---|
| 345 | {
|
|---|
| 346 | char *s;
|
|---|
| 347 | copy_axis(g->x_axis, lastg->x_axis);
|
|---|
| 348 | copy_axis(g->y_axis, lastg->y_axis);
|
|---|
| 349 | g->x_translate = lastg->x_translate;
|
|---|
| 350 | g->y_translate = lastg->y_translate;
|
|---|
| 351 | g->clip = lastg->clip;
|
|---|
| 352 | g->border = lastg->border;
|
|---|
| 353 | copy_legend(g->legend, lastg->legend);
|
|---|
| 354 | s = g->title->label;
|
|---|
| 355 | copy_label(g->title, lastg->title);
|
|---|
| 356 | g->title->label = s;
|
|---|
| 357 | }
|
|---|
| 358 |
|
|---|
| 359 | getpattern(inp_str, key, p, a)
|
|---|
| 360 | char *inp_str, *key, *p;
|
|---|
| 361 | float *a;
|
|---|
| 362 | {
|
|---|
| 363 | int i;
|
|---|
| 364 | float f;
|
|---|
| 365 |
|
|---|
| 366 | if (!getstring(inp_str)) return;
|
|---|
| 367 | for (i = 0; i < NPATTERNS; i++) {
|
|---|
| 368 | if (strcmp(inp_str, PATTERNS[i]) == 0) {
|
|---|
| 369 | *p = PTYPES[i];
|
|---|
| 370 | if (getfloat(&f)) {
|
|---|
| 371 | *a = f;
|
|---|
| 372 | } else {
|
|---|
| 373 | rejecttoken();
|
|---|
| 374 | }
|
|---|
| 375 | i = NPATTERNS + 1;
|
|---|
| 376 | }
|
|---|
| 377 | }
|
|---|
| 378 | if (i == NPATTERNS) {
|
|---|
| 379 | error_header(); fprintf(stderr, "Bad %s: %s\n", key, inp_str);
|
|---|
| 380 | error_header(); fprintf(stderr, " Valid %ss are:", key);
|
|---|
| 381 | for (i = 0; i < NPATTERNS; i++) fprintf(stderr, " %s", PATTERNS[i]);
|
|---|
| 382 | fprintf(stderr, "\n");
|
|---|
| 383 | exit(1);
|
|---|
| 384 | }
|
|---|
| 385 | return;
|
|---|
| 386 | }
|
|---|
| 387 |
|
|---|
| 388 | edit_curve(c, g)
|
|---|
| 389 | Curve c;
|
|---|
| 390 | Graph g;
|
|---|
| 391 | {
|
|---|
| 392 | char inp_str[256], *txt;
|
|---|
| 393 | float x, y, f, e1, e2;
|
|---|
| 394 | float xh, yh, xl, yl;
|
|---|
| 395 | Point p, p1, p2;
|
|---|
| 396 | Flist fl;
|
|---|
| 397 | FILE *fi;
|
|---|
| 398 | int i;
|
|---|
| 399 | char e;
|
|---|
| 400 |
|
|---|
| 401 | while ( getstring(inp_str) ) {
|
|---|
| 402 | if (strcmp(inp_str, "y_epts") == 0 ||
|
|---|
| 403 | strcmp(inp_str, "pts") == 0 ||
|
|---|
| 404 | strcmp(inp_str, "x_epts") == 0) {
|
|---|
| 405 | e = inp_str[0];
|
|---|
| 406 | while (getfloat(&x)) {
|
|---|
| 407 | if (e == 'p') {
|
|---|
| 408 | if (!getfloat(&y)) {
|
|---|
| 409 | error_header();
|
|---|
| 410 | fprintf(stderr, "Reading Points, no y value for x=%f\n", x);
|
|---|
| 411 | exit(1);
|
|---|
| 412 | }
|
|---|
| 413 | } else {
|
|---|
| 414 | if (!getfloat(&y) || !getfloat(&e1) || !getfloat(&e2)) {
|
|---|
| 415 | error_header();
|
|---|
| 416 | fprintf(stderr,
|
|---|
| 417 | "Reading %s, need 4 values per data point\n", inp_str);
|
|---|
| 418 | exit(1);
|
|---|
| 419 | }
|
|---|
| 420 | }
|
|---|
| 421 | p = (Point) get_node(c->pts);
|
|---|
| 422 | p->x = x;
|
|---|
| 423 | p->y = y;
|
|---|
| 424 | p->e = e;
|
|---|
| 425 | insert(p, c->pts);
|
|---|
| 426 | c->npts++;
|
|---|
| 427 | if (e == 'x') {
|
|---|
| 428 | p1 = (Point) get_node(c->xepts);
|
|---|
| 429 | p1->x = e1;
|
|---|
| 430 | p1->y = y;
|
|---|
| 431 | p2 = (Point) get_node(c->xepts);
|
|---|
| 432 | p2->x = e2;
|
|---|
| 433 | p2->y = y;
|
|---|
| 434 | insert(p1, c->xepts);
|
|---|
| 435 | insert(p2, c->xepts);
|
|---|
| 436 | xh = MAX(e1, e2); xh = MAX(xh, x);
|
|---|
| 437 | xl = MIN(e1, e2); xl = MIN(xl, x);
|
|---|
| 438 | yh = y; yl = y;
|
|---|
| 439 | } else if (e == 'y') {
|
|---|
| 440 | p1 = (Point) get_node(c->yepts);
|
|---|
| 441 | p1->y = e1;
|
|---|
| 442 | p1->x = x;
|
|---|
| 443 | p2 = (Point) get_node(c->yepts);
|
|---|
| 444 | p2->y = e2;
|
|---|
| 445 | p2->x = x;
|
|---|
| 446 | insert(p1, c->yepts);
|
|---|
| 447 | insert(p2, c->yepts);
|
|---|
| 448 | yh = MAX(e1, e2); yh = MAX(yh, y);
|
|---|
| 449 | yl = MIN(e1, e2); yl = MIN(yl, y);
|
|---|
| 450 | xh = x; xl = x;
|
|---|
| 451 | } else {
|
|---|
| 452 | xh = x; xl = x; yh = y; yl = y;
|
|---|
| 453 | }
|
|---|
| 454 | if (g->x_axis->pmax == FSIG) {
|
|---|
| 455 | g->x_axis->pmax = xh;
|
|---|
| 456 | g->x_axis->pmin = xl;
|
|---|
| 457 | g->y_axis->pmax = yh;
|
|---|
| 458 | g->y_axis->pmin = yl;
|
|---|
| 459 | } else {
|
|---|
| 460 | g->x_axis->pmax = MAX(g->x_axis->pmax, xh);
|
|---|
| 461 | g->x_axis->pmin = MIN(g->x_axis->pmin, xl);
|
|---|
| 462 | g->y_axis->pmax = MAX(g->y_axis->pmax, yh);
|
|---|
| 463 | g->y_axis->pmin = MIN(g->y_axis->pmin, yl);
|
|---|
| 464 | }
|
|---|
| 465 | }
|
|---|
| 466 | rejecttoken();
|
|---|
| 467 |
|
|---|
| 468 | } else if (strcmp(inp_str, "label") == 0) {
|
|---|
| 469 | edit_label(c->l);
|
|---|
| 470 | } else if (strcmp(inp_str, "marksize") == 0) {
|
|---|
| 471 | if (!getfloat(&f)) rejecttoken();
|
|---|
| 472 | else {
|
|---|
| 473 | c->marksize[0] = f;
|
|---|
| 474 | if (!getfloat(&f)) rejecttoken();
|
|---|
| 475 | else c->marksize[1] = f;
|
|---|
| 476 | }
|
|---|
| 477 | } else if (strcmp(inp_str, "gmarks") == 0) {
|
|---|
| 478 | while (getfloat(&x)) {
|
|---|
| 479 | if (!getfloat(&y)) {
|
|---|
| 480 | error_header();
|
|---|
| 481 | fprintf(stderr, "Reading GMarks, no y value for x=%f\n", x);
|
|---|
| 482 | exit(1);
|
|---|
| 483 | }
|
|---|
| 484 | p = (Point) get_node(c->general_marks);
|
|---|
| 485 | p->x = x;
|
|---|
| 486 | p->y = y;
|
|---|
| 487 | insert(p, c->general_marks);
|
|---|
| 488 | }
|
|---|
| 489 | rejecttoken();
|
|---|
| 490 | } else if (strcmp(inp_str, "pfill") == 0) {
|
|---|
| 491 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 492 | /* grey fill */
|
|---|
| 493 | c->pfilltype = 'g';
|
|---|
| 494 | c->pfill[0] = f;
|
|---|
| 495 | }
|
|---|
| 496 | } else if (strcmp(inp_str, "pcfill") == 0) {
|
|---|
| 497 | /* color fill */
|
|---|
| 498 | c->pfilltype = 'c';
|
|---|
| 499 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 500 | if(!getfloat(&f)) {
|
|---|
| 501 | rejecttoken();
|
|---|
| 502 | c->pfilltype = 'n';
|
|---|
| 503 | break ;
|
|---|
| 504 | } else c->pfill[i] = f ;
|
|---|
| 505 | }
|
|---|
| 506 | } else if (strcmp(inp_str, "fill") == 0) {
|
|---|
| 507 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 508 | /* grey fill */
|
|---|
| 509 | c->filltype = 'g';
|
|---|
| 510 | c->fill[0] = f;
|
|---|
| 511 | }
|
|---|
| 512 | } else if (strcmp(inp_str, "cfill") == 0) {
|
|---|
| 513 | /* color fill */
|
|---|
| 514 | c->filltype = 'c';
|
|---|
| 515 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 516 | if(!getfloat(&f)) {
|
|---|
| 517 | rejecttoken();
|
|---|
| 518 | c->filltype = 'n';
|
|---|
| 519 | break ;
|
|---|
| 520 | } else c->fill[i] = f ;
|
|---|
| 521 | }
|
|---|
| 522 | } else if (strcmp(inp_str, "afill") == 0) {
|
|---|
| 523 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 524 | c->afilltype = 'g';
|
|---|
| 525 | c->afill[0] = f;
|
|---|
| 526 | }
|
|---|
| 527 | } else if (strcmp(inp_str, "acfill") == 0) {
|
|---|
| 528 | c->afilltype = 'c';
|
|---|
| 529 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 530 | if(!getfloat(&f)) {
|
|---|
| 531 | rejecttoken();
|
|---|
| 532 | c->afilltype = 'n';
|
|---|
| 533 | break ;
|
|---|
| 534 | } else c->afill[i] = f ;
|
|---|
| 535 | }
|
|---|
| 536 | } else if (strcmp(inp_str, "marktype") == 0) {
|
|---|
| 537 | if (!getstring(inp_str)) return;
|
|---|
| 538 | for (i = 0; i < NMARKTYPES && strcmp(inp_str, MARKTYPESTRS[i]) != 0; i++) ;
|
|---|
| 539 | if (i == NMARKTYPES) {
|
|---|
| 540 | error_header(); fprintf(stderr, "Bad mark: %s\n", inp_str);
|
|---|
| 541 | fprintf(stderr, " Valid marks are:");
|
|---|
| 542 | for (i = 0; i < NMARKTYPES; i++) {
|
|---|
| 543 | fprintf(stderr, " %s", MARKTYPESTRS[i]);
|
|---|
| 544 | }
|
|---|
| 545 | fprintf(stderr, "\n");
|
|---|
| 546 | exit(1);
|
|---|
| 547 | } else {
|
|---|
| 548 | c->marktype = MARKTYPES[i];
|
|---|
| 549 | if (c->marktype == 'l') edit_label(c->lmark);
|
|---|
| 550 | }
|
|---|
| 551 | } else if (strcmp(inp_str, "glines") == 0) {
|
|---|
| 552 | while (getfloat(&f)) {
|
|---|
| 553 | fl = (Flist) get_node (c->gen_linetype);
|
|---|
| 554 | fl->f = f;
|
|---|
| 555 | insert(fl, c->gen_linetype);
|
|---|
| 556 | }
|
|---|
| 557 | rejecttoken();
|
|---|
| 558 | } else if (strcmp(inp_str, "pattern") == 0) {
|
|---|
| 559 | getpattern(inp_str, "pattern", &(c->pattern), &(c->parg));
|
|---|
| 560 | } else if (strcmp(inp_str, "apattern") == 0) {
|
|---|
| 561 | getpattern(inp_str, "apattern", &(c->apattern), &(c->aparg));
|
|---|
| 562 | } else if (strcmp(inp_str, "ppattern") == 0) {
|
|---|
| 563 | getpattern(inp_str, "ppattern", &(c->ppattern), &(c->pparg));
|
|---|
| 564 |
|
|---|
| 565 | } else if (strcmp(inp_str, "linetype") == 0) {
|
|---|
| 566 | if (!getstring(inp_str)) return;
|
|---|
| 567 | if (strcmp(inp_str, "none") == 0) c->linetype = '0';
|
|---|
| 568 | else if (strcmp(inp_str, "solid") == 0) c->linetype = 's';
|
|---|
| 569 | else if (strcmp(inp_str, "dotted") == 0) c->linetype = '.';
|
|---|
| 570 | else if (strcmp(inp_str, "dashed") == 0) c->linetype = '-';
|
|---|
| 571 | else if (strcmp(inp_str, "longdash") == 0) c->linetype = 'l';
|
|---|
| 572 | else if (strcmp(inp_str, "dotdash") == 0) c->linetype = 'd';
|
|---|
| 573 | else if (strcmp(inp_str, "dotdotdash") == 0) c->linetype = 'D';
|
|---|
| 574 | else if (strcmp(inp_str, "dotdotdashdash") == 0) c->linetype = '2';
|
|---|
| 575 | else if (strcmp(inp_str, "general") == 0) c->linetype = 'g';
|
|---|
| 576 | else {
|
|---|
| 577 | error_header(); fprintf(stderr, "Bad line type: %s\n", inp_str);
|
|---|
| 578 | error_header(); fprintf(stderr, " Valid marks are %s\n",
|
|---|
| 579 | "solid, dotted, dashed, longdash, dotdash,");
|
|---|
| 580 | error_header(); fprintf(stderr, " %s.\n",
|
|---|
| 581 | "dotdotdash, dotdotdashdash, none");
|
|---|
| 582 | exit(1);
|
|---|
| 583 | }
|
|---|
| 584 | } else if (strcmp(inp_str, "linethickness") == 0) {
|
|---|
| 585 | if (!getfloat(&f)) rejecttoken(); else c->linethick = f;
|
|---|
| 586 | } else if (strcmp(inp_str, "gray") == 0) {
|
|---|
| 587 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 588 | c->graytype = 'g';
|
|---|
| 589 | c->gray[0] = f;
|
|---|
| 590 | }
|
|---|
| 591 | } else if (strcmp(inp_str, "color") == 0) {
|
|---|
| 592 | c->graytype = 'c';
|
|---|
| 593 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 594 | if(!getfloat(&f)) {
|
|---|
| 595 | rejecttoken();
|
|---|
| 596 | c->graytype = 'n';
|
|---|
| 597 | break ;
|
|---|
| 598 | } else c->gray[i] = f ;
|
|---|
| 599 | }
|
|---|
| 600 | } else if (strcmp(inp_str, "mrotate") == 0) {
|
|---|
| 601 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 602 | c->mrotate = f;
|
|---|
| 603 | }
|
|---|
| 604 | } else if (strcmp(inp_str, "eps") == 0) {
|
|---|
| 605 | if (!getstring(inp_str)) {
|
|---|
| 606 | error_header();
|
|---|
| 607 | fprintf(stderr, "eps token must be followed by an %s\n",
|
|---|
| 608 | "encapsulated postscript file\n");
|
|---|
| 609 | exit(1);
|
|---|
| 610 | }
|
|---|
| 611 | c->marktype = 'E';
|
|---|
| 612 | c->eps = (char *) malloc ((strlen(inp_str)+1)*sizeof(char));
|
|---|
| 613 | strcpy(c->eps, inp_str);
|
|---|
| 614 | fi = fopen(c->eps, "r");
|
|---|
| 615 | if (fi == NULL) {
|
|---|
| 616 | error_header();
|
|---|
| 617 | fprintf(stderr, "couldn't open eps file '%s'\n", c->eps);
|
|---|
| 618 | exit(1);
|
|---|
| 619 | }
|
|---|
| 620 | fclose(fi);
|
|---|
| 621 | } else if (strcmp(inp_str, "postscript") == 0) {
|
|---|
| 622 | if (!getstring(inp_str)) return;
|
|---|
| 623 | c->marktype = 'p';
|
|---|
| 624 | if (strcmp(inp_str, ":") == 0) {
|
|---|
| 625 | c->postfile = 0;
|
|---|
| 626 | if ((txt = getmultiline()) == CNULL) return;
|
|---|
| 627 | c->postscript = txt;
|
|---|
| 628 | } else {
|
|---|
| 629 | c->postfile = 1;
|
|---|
| 630 | c->postscript = (char *) malloc ((strlen(inp_str)+1)*sizeof(char));
|
|---|
| 631 | strcpy(c->postscript, inp_str);
|
|---|
| 632 | fi = fopen(c->postscript, "r");
|
|---|
| 633 | if (fi == NULL) {
|
|---|
| 634 | error_header();
|
|---|
| 635 | fprintf(stderr, "couldn't open postscript file '%s'\n",
|
|---|
| 636 | c->postscript);
|
|---|
| 637 | exit(1);
|
|---|
| 638 | }
|
|---|
| 639 | fclose(fi);
|
|---|
| 640 | }
|
|---|
| 641 | } else if (strcmp(inp_str, "poly") == 0) {
|
|---|
| 642 | c->poly = 1;
|
|---|
| 643 | } else if (strcmp(inp_str, "nopoly") == 0) {
|
|---|
| 644 | c->poly = 0;
|
|---|
| 645 | } else if (strcmp(inp_str, "larrow") == 0) {
|
|---|
| 646 | c->larrow = 1;
|
|---|
| 647 | } else if (strcmp(inp_str, "nolarrow") == 0) {
|
|---|
| 648 | c->larrow = 0;
|
|---|
| 649 | } else if (strcmp(inp_str, "rarrow") == 0) {
|
|---|
| 650 | c->rarrow = 1;
|
|---|
| 651 | } else if (strcmp(inp_str, "norarrow") == 0) {
|
|---|
| 652 | c->rarrow = 0;
|
|---|
| 653 | } else if (strcmp(inp_str, "larrows") == 0) {
|
|---|
| 654 | c->larrows = 1;
|
|---|
| 655 | } else if (strcmp(inp_str, "nolarrows") == 0) {
|
|---|
| 656 | c->larrows = 0;
|
|---|
| 657 | } else if (strcmp(inp_str, "rarrows") == 0) {
|
|---|
| 658 | c->rarrows = 1;
|
|---|
| 659 | } else if (strcmp(inp_str, "norarrows") == 0) {
|
|---|
| 660 | c->rarrows = 0;
|
|---|
| 661 | } else if (strcmp(inp_str, "bezier") == 0) {
|
|---|
| 662 | c->bezier = 1;
|
|---|
| 663 | } else if (strcmp(inp_str, "nobezier") == 0) {
|
|---|
| 664 | c->bezier = 0;
|
|---|
| 665 | } else if (strcmp(inp_str, "asize") == 0) {
|
|---|
| 666 | if (!getfloat(&f)) rejecttoken();
|
|---|
| 667 | else {
|
|---|
| 668 | c->asize[0] = f;
|
|---|
| 669 | if (!getfloat(&f)) rejecttoken();
|
|---|
| 670 | else c->asize[1] = f;
|
|---|
| 671 | }
|
|---|
| 672 | } else if (strcmp(inp_str, "clip") == 0) {
|
|---|
| 673 | c->clip = 1;
|
|---|
| 674 | } else if (strcmp(inp_str, "noclip") == 0) {
|
|---|
| 675 | c->clip = 0;
|
|---|
| 676 | } else {
|
|---|
| 677 | rejecttoken();
|
|---|
| 678 | return;
|
|---|
| 679 | }
|
|---|
| 680 | }
|
|---|
| 681 | }
|
|---|
| 682 |
|
|---|
| 683 | edit_hash_label(a)
|
|---|
| 684 | Axis a;
|
|---|
| 685 | {
|
|---|
| 686 | float at, f;
|
|---|
| 687 | char *s;
|
|---|
| 688 | char inp_str[256];
|
|---|
| 689 | String st;
|
|---|
| 690 | int done;
|
|---|
| 691 |
|
|---|
| 692 | s = CNULL;
|
|---|
| 693 |
|
|---|
| 694 | at = (first(a->hash_lines) == nil(a->hash_lines)) ? FSIG
|
|---|
| 695 | : first(a->hash_lines)->loc;
|
|---|
| 696 | while(1) {
|
|---|
| 697 | done = 0;
|
|---|
| 698 | if (getstring(inp_str)) {
|
|---|
| 699 | if (strcmp(inp_str, ":") == 0) {
|
|---|
| 700 | if ((s = getlabel()) == CNULL) return;
|
|---|
| 701 | } else if (strcmp(inp_str, "at") == 0) {
|
|---|
| 702 | if (getfloat(&f)) {
|
|---|
| 703 | at = f;
|
|---|
| 704 | } else {
|
|---|
| 705 | rejecttoken();
|
|---|
| 706 | done = 1;
|
|---|
| 707 | }
|
|---|
| 708 | } else {
|
|---|
| 709 | rejecttoken();
|
|---|
| 710 | done = 1;
|
|---|
| 711 | }
|
|---|
| 712 | } else {
|
|---|
| 713 | done = 1;
|
|---|
| 714 | }
|
|---|
| 715 | if (done) {
|
|---|
| 716 | if (s == CNULL) return;
|
|---|
| 717 | if (at == FSIG) {
|
|---|
| 718 | error_header();
|
|---|
| 719 | fprintf(stderr,
|
|---|
| 720 | "hash_label either needs \"at\" or an associated \"hash_at\"\n");
|
|---|
| 721 | exit(1);
|
|---|
| 722 | }
|
|---|
| 723 | st = (String) get_node(a->hash_labels);
|
|---|
| 724 | st->s = new_label();
|
|---|
| 725 | st->s->label = s;
|
|---|
| 726 | st->s->x = at;
|
|---|
| 727 | st->s->y = at;
|
|---|
| 728 | insert(st, a->hash_labels);
|
|---|
| 729 | return;
|
|---|
| 730 | }
|
|---|
| 731 | }
|
|---|
| 732 | }
|
|---|
| 733 |
|
|---|
| 734 | edit_axis(a)
|
|---|
| 735 | Axis a;
|
|---|
| 736 | {
|
|---|
| 737 | char inp_str[256];
|
|---|
| 738 | float f;
|
|---|
| 739 | int i;
|
|---|
| 740 | Hash h;
|
|---|
| 741 |
|
|---|
| 742 | while ( getstring(inp_str) ) {
|
|---|
| 743 |
|
|---|
| 744 | if (strcmp(inp_str, "size") == 0) {
|
|---|
| 745 | if ( getfloat(&f)) a->size = f; else rejecttoken();
|
|---|
| 746 | } else if (strcmp(inp_str, "max") == 0) {
|
|---|
| 747 | if ( getfloat(&f)) a->max = f; else rejecttoken();
|
|---|
| 748 | } else if (strcmp(inp_str, "min") == 0) {
|
|---|
| 749 | if ( getfloat(&f)) a->min = f; else rejecttoken();
|
|---|
| 750 | } else if (strcmp(inp_str, "hash") == 0) {
|
|---|
| 751 | if ( getfloat(&f)) a->hash_interval = f; else rejecttoken();
|
|---|
| 752 | } else if (strcmp(inp_str, "shash") == 0) {
|
|---|
| 753 | if ( getfloat(&f)) {
|
|---|
| 754 | a->hash_start = f;
|
|---|
| 755 | a->start_given = 1;
|
|---|
| 756 | }
|
|---|
| 757 | else rejecttoken();
|
|---|
| 758 | } else if (strcmp(inp_str, "mhash") == 0) {
|
|---|
| 759 | if (getint(&i)) a->minor_hashes = i; else rejecttoken();
|
|---|
| 760 | } else if (strcmp(inp_str, "precision") == 0) {
|
|---|
| 761 | if (getint(&i)) a->precision = i; else rejecttoken();
|
|---|
| 762 | } else if (strcmp(inp_str, "label") == 0) {
|
|---|
| 763 | edit_label(a->label);
|
|---|
| 764 | } else if (strcmp(inp_str, "hash_format") == 0) {
|
|---|
| 765 | if (!getstring(inp_str)) return;
|
|---|
| 766 | if (strcmp(inp_str, "g") == 0) {
|
|---|
| 767 | a->hash_format = 'g';
|
|---|
| 768 | } else if (strcmp(inp_str, "G") == 0) {
|
|---|
| 769 | a->hash_format = 'G';
|
|---|
| 770 | } else if (strcmp(inp_str, "E") == 0) {
|
|---|
| 771 | a->hash_format = 'E';
|
|---|
| 772 | } else if (strcmp(inp_str, "e") == 0) {
|
|---|
| 773 | a->hash_format = 'e';
|
|---|
| 774 | } else if (strcmp(inp_str, "f") == 0) {
|
|---|
| 775 | a->hash_format = 'f';
|
|---|
| 776 | } else {
|
|---|
| 777 | error_header();
|
|---|
| 778 | fprintf(stderr, "Invalid hash_style %s. Must be f, g, G, e or E\n",
|
|---|
| 779 | inp_str);
|
|---|
| 780 | exit(1);
|
|---|
| 781 | }
|
|---|
| 782 | } else if (strcmp(inp_str, "hash_labels") == 0) {
|
|---|
| 783 | edit_label(a->hl);
|
|---|
| 784 | } else if (strcmp(inp_str, "log_base") == 0) {
|
|---|
| 785 | if (getfloat(&f)) {
|
|---|
| 786 | if (f <= 1.0) {
|
|---|
| 787 | error_header();
|
|---|
| 788 | fprintf(stderr, "\"log_base %f\": log_base must be > 1.0\n", f);
|
|---|
| 789 | exit(1);
|
|---|
| 790 | } else a->log_base = f;
|
|---|
| 791 | } else rejecttoken();
|
|---|
| 792 | } else if (strcmp(inp_str, "draw_at") == 0) {
|
|---|
| 793 | if ( getfloat(&f)) a->draw_at = f; else rejecttoken();
|
|---|
| 794 | } else if (strcmp(inp_str, "log") == 0) {
|
|---|
| 795 | a->is_lg = 1;
|
|---|
| 796 | } else if (strcmp(inp_str, "linear") == 0) {
|
|---|
| 797 | a->is_lg = 0;
|
|---|
| 798 | } else if (strcmp(inp_str, "nodraw") == 0) {
|
|---|
| 799 | a->draw_hash_labels = 0;
|
|---|
| 800 | a->draw_axis_line = 0;
|
|---|
| 801 | a->draw_hash_marks = 0;
|
|---|
| 802 | a->draw_axis_label = 0;
|
|---|
| 803 | } else if (strcmp(inp_str, "draw") == 0) {
|
|---|
| 804 | a->draw_hash_labels = 1;
|
|---|
| 805 | a->draw_axis_line = 1;
|
|---|
| 806 | a->draw_hash_marks = 1;
|
|---|
| 807 | a->draw_axis_label = 1;
|
|---|
| 808 | } else if (strcmp(inp_str, "hash_at") == 0 ||
|
|---|
| 809 | strcmp(inp_str, "mhash_at") == 0) {
|
|---|
| 810 | if (getfloat(&f)) {
|
|---|
| 811 | h = (Hash) get_node (a->hash_lines);
|
|---|
| 812 | h->loc = f;
|
|---|
| 813 | h->major = (inp_str[0] == 'h');
|
|---|
| 814 | h->size = h->major ? HASH_SIZE : MHASH_SIZE;
|
|---|
| 815 | insert(h, a->hash_lines);
|
|---|
| 816 | } else rejecttoken();
|
|---|
| 817 | } else if (strcmp(inp_str, "hash_label") == 0) {
|
|---|
| 818 | edit_hash_label(a);
|
|---|
| 819 | } else if (strcmp(inp_str, "hash_scale") == 0) {
|
|---|
| 820 | if ( getfloat(&f)) a->hash_scale = f; else rejecttoken();
|
|---|
| 821 | } else if (strcmp(inp_str, "auto_hash_marks") == 0) {
|
|---|
| 822 | a->auto_hash_marks = 1;
|
|---|
| 823 | } else if (strcmp(inp_str, "no_auto_hash_marks") == 0) {
|
|---|
| 824 | a->auto_hash_marks = 0;
|
|---|
| 825 | } else if (strcmp(inp_str, "auto_hash_labels") == 0) {
|
|---|
| 826 | a->auto_hash_labels = 1;
|
|---|
| 827 | } else if (strcmp(inp_str, "no_auto_hash_labels") == 0) {
|
|---|
| 828 | a->auto_hash_labels = 0;
|
|---|
| 829 | } else if (strcmp(inp_str, "draw_hash_labels_at") == 0) {
|
|---|
| 830 | if (getfloat(&f)) a->draw_hash_labels_at = f; else rejecttoken();
|
|---|
| 831 | } else if (strcmp(inp_str, "draw_hash_marks_at") == 0) {
|
|---|
| 832 | if (getfloat(&f)) a->draw_hash_marks_at = f; else rejecttoken();
|
|---|
| 833 | } else if (strcmp(inp_str, "no_draw_hash_labels") == 0) {
|
|---|
| 834 | a->draw_hash_labels = 0;
|
|---|
| 835 | } else if (strcmp(inp_str, "draw_hash_labels") == 0) {
|
|---|
| 836 | a->draw_hash_labels = 1;
|
|---|
| 837 | } else if (strcmp(inp_str, "no_draw_axis_line") == 0) {
|
|---|
| 838 | a->draw_axis_line = 0;
|
|---|
| 839 | } else if (strcmp(inp_str, "draw_axis_line") == 0) {
|
|---|
| 840 | a->draw_axis_line = 1;
|
|---|
| 841 | } else if (strcmp(inp_str, "no_draw_axis") == 0) {
|
|---|
| 842 | a->draw_axis_line = 0;
|
|---|
| 843 | } else if (strcmp(inp_str, "draw_axis") == 0) {
|
|---|
| 844 | a->draw_axis_line = 1;
|
|---|
| 845 | } else if (strcmp(inp_str, "no_draw_hash_marks") == 0) {
|
|---|
| 846 | a->draw_hash_marks = 0;
|
|---|
| 847 | } else if (strcmp(inp_str, "draw_hash_marks") == 0) {
|
|---|
| 848 | a->draw_hash_marks = 1;
|
|---|
| 849 | } else if (strcmp(inp_str, "no_draw_axis_label") == 0) {
|
|---|
| 850 | a->draw_axis_label = 0;
|
|---|
| 851 | } else if (strcmp(inp_str, "draw_axis_label") == 0) {
|
|---|
| 852 | a->draw_axis_label = 1;
|
|---|
| 853 | } else if (strcmp(inp_str, "no_grid_lines") == 0) {
|
|---|
| 854 | a->grid_lines = 0;
|
|---|
| 855 | } else if (strcmp(inp_str, "grid_lines") == 0) {
|
|---|
| 856 | a->grid_lines = 1;
|
|---|
| 857 | } else if (strcmp(inp_str, "no_mgrid_lines") == 0) {
|
|---|
| 858 | a->mgrid_lines = 0;
|
|---|
| 859 | } else if (strcmp(inp_str, "mgrid_lines") == 0) {
|
|---|
| 860 | a->mgrid_lines = 1;
|
|---|
| 861 | } else if (strcmp(inp_str, "gray") == 0) {
|
|---|
| 862 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 863 | a->graytype = 'g';
|
|---|
| 864 | a->gray[0] = f;
|
|---|
| 865 | }
|
|---|
| 866 | } else if (strcmp(inp_str, "color") == 0) {
|
|---|
| 867 | a->graytype = 'c';
|
|---|
| 868 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 869 | if(!getfloat(&f)) {
|
|---|
| 870 | rejecttoken();
|
|---|
| 871 | a->graytype = 'n';
|
|---|
| 872 | break ;
|
|---|
| 873 | } else a->gray[i] = f ;
|
|---|
| 874 | }
|
|---|
| 875 | } else if (strcmp(inp_str, "grid_gray") == 0) {
|
|---|
| 876 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 877 | a->gr_graytype = 'g';
|
|---|
| 878 | a->gr_gray[0] = f;
|
|---|
| 879 | }
|
|---|
| 880 | } else if (strcmp(inp_str, "grid_color") == 0) {
|
|---|
| 881 | a->gr_graytype = 'c';
|
|---|
| 882 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 883 | if(!getfloat(&f)) {
|
|---|
| 884 | rejecttoken();
|
|---|
| 885 | a->gr_graytype = 'n';
|
|---|
| 886 | break ;
|
|---|
| 887 | } else a->gr_gray[i] = f ;
|
|---|
| 888 | }
|
|---|
| 889 | } else if (strcmp(inp_str, "mgrid_gray") == 0) {
|
|---|
| 890 | if (!getfloat(&f)) rejecttoken(); else {
|
|---|
| 891 | a->mgr_graytype = 'g';
|
|---|
| 892 | a->mgr_gray[0] = f;
|
|---|
| 893 | }
|
|---|
| 894 | } else if (strcmp(inp_str, "mgrid_color") == 0) {
|
|---|
| 895 | a->mgr_graytype = 'c';
|
|---|
| 896 | for( i = 0 ; i < 3 ; i++ ) {
|
|---|
| 897 | if(!getfloat(&f)) {
|
|---|
| 898 | rejecttoken();
|
|---|
| 899 | a->mgr_graytype = 'n';
|
|---|
| 900 | break ;
|
|---|
| 901 | } else a->mgr_gray[i] = f ;
|
|---|
| 902 | }
|
|---|
| 903 | } else {
|
|---|
| 904 | rejecttoken();
|
|---|
| 905 | return;
|
|---|
| 906 | }
|
|---|
| 907 | }
|
|---|
| 908 | }
|
|---|
| 909 |
|
|---|
| 910 | edit_legend(l)
|
|---|
| 911 | Legend l;
|
|---|
| 912 | {
|
|---|
| 913 | char inp_str[256];
|
|---|
| 914 | float f;
|
|---|
| 915 |
|
|---|
| 916 | while ( getstring(inp_str) ) {
|
|---|
| 917 | if (strcmp(inp_str, "x") == 0) {
|
|---|
| 918 | if (!getfloat(&f)) rejecttoken();
|
|---|
| 919 | else {
|
|---|
| 920 | l->l->x = f;
|
|---|
| 921 | l->l->hj = 'l';
|
|---|
| 922 | l->l->vj = 't';
|
|---|
| 923 | l->type = 'u';
|
|---|
| 924 | }
|
|---|
| 925 | } else if (strcmp(inp_str, "y") == 0) {
|
|---|
| 926 | if (!getfloat(&f)) rejecttoken();
|
|---|
| 927 | else {
|
|---|
| 928 | l->l->y = f;
|
|---|
| 929 | l->l->hj = 'l';
|
|---|
| 930 | l->l->vj = 't';
|
|---|
| 931 | l->type = 'u';
|
|---|
| 932 | }
|
|---|
| 933 | } else if (strcmp(inp_str, "right") == 0 ||
|
|---|
| 934 | strcmp(inp_str, "on") == 0) {
|
|---|
| 935 | l->type = 'u';
|
|---|
| 936 | l->l->y = FSIG;
|
|---|
| 937 | l->l->x = FSIG;
|
|---|
| 938 | l->l->hj = 'l';
|
|---|
| 939 | l->l->vj = 'c';
|
|---|
| 940 | } else if (strcmp(inp_str, "left") == 0) {
|
|---|
| 941 | l->type = 'u';
|
|---|
| 942 | l->l->y = FSIG;
|
|---|
| 943 | l->l->x = FSIG;
|
|---|
| 944 | l->l->hj = 'r';
|
|---|
| 945 | l->l->vj = 'c';
|
|---|
| 946 | } else if (strcmp(inp_str, "off") == 0) {
|
|---|
| 947 | l->type = 'n';
|
|---|
| 948 | } else if (strcmp(inp_str, "top") == 0) {
|
|---|
| 949 | l->type = 'u';
|
|---|
| 950 | l->l->y = FSIG;
|
|---|
| 951 | l->l->x = FSIG;
|
|---|
| 952 | l->l->hj = 'l';
|
|---|
| 953 | l->l->vj = 'b';
|
|---|
| 954 | } else if (strcmp(inp_str, "bottom") == 0) {
|
|---|
| 955 | l->type = 'u';
|
|---|
| 956 | l->l->y = FSIG;
|
|---|
| 957 | l->l->x = FSIG;
|
|---|
| 958 | l->l->hj = 'l';
|
|---|
| 959 | l->l->vj = 't';
|
|---|
| 960 | } else if (strcmp(inp_str, "custom") == 0) {
|
|---|
| 961 | l->type = 'c';
|
|---|
| 962 | } else if (strcmp(inp_str, "linelength") == 0) {
|
|---|
| 963 | if (!getfloat(&f)) rejecttoken(); else l->linelength = f;
|
|---|
| 964 | } else if (strcmp(inp_str, "linebreak") == 0) {
|
|---|
| 965 | if (!getfloat(&f)) rejecttoken(); else l->linebreak = f;
|
|---|
| 966 | } else if (strcmp(inp_str, "midspace") == 0) {
|
|---|
| 967 | if (!getfloat(&f)) rejecttoken(); else l->midspace = f;
|
|---|
| 968 | } else if (strcmp(inp_str, "defaults") == 0) {
|
|---|
| 969 | edit_label(l->l);
|
|---|
| 970 | } else {
|
|---|
| 971 | rejecttoken();
|
|---|
| 972 | return;
|
|---|
| 973 | }
|
|---|
| 974 | }
|
|---|
| 975 | }
|
|---|
| 976 |
|
|---|
| 977 | edit_graph(g, gs, all_gs)
|
|---|
| 978 | Graph g;
|
|---|
| 979 | Graphs gs;
|
|---|
| 980 | Graphs all_gs;
|
|---|
| 981 | {
|
|---|
| 982 | char inp_str[80];
|
|---|
| 983 | int num;
|
|---|
| 984 | String s;
|
|---|
| 985 | float f;
|
|---|
| 986 |
|
|---|
| 987 | while ( getstring(inp_str) ) {
|
|---|
| 988 | if (strcmp(inp_str, "xaxis") == 0)
|
|---|
| 989 | edit_axis(g->x_axis);
|
|---|
| 990 | else if (strcmp(inp_str, "yaxis") == 0)
|
|---|
| 991 | edit_axis(g->y_axis);
|
|---|
| 992 | else if (strcmp(inp_str, "curve") == 0) {
|
|---|
| 993 | if (!getint(&num)) {
|
|---|
| 994 | error_header(); fprintf(stderr, "\"curve\" not followed by number\n");
|
|---|
| 995 | exit(1);
|
|---|
| 996 | }
|
|---|
| 997 | edit_curve(get_curve(g->curves, num), g);
|
|---|
| 998 | } else if (strcmp(inp_str, "newcurve") == 0) {
|
|---|
| 999 | if (first(g->curves) == nil(g->curves))
|
|---|
| 1000 | edit_curve(new_curve(g->curves, 0), g);
|
|---|
| 1001 | else edit_curve(new_curve(g->curves, last(g->curves)->num + 1), g);
|
|---|
| 1002 | } else if (strcmp(inp_str, "copycurve") == 0) {
|
|---|
| 1003 | edit_curve(do_copy_curve(g, gs, all_gs), g);
|
|---|
| 1004 | } else if (strcmp(inp_str, "newline") == 0) {
|
|---|
| 1005 | if (first(g->curves) == nil(g->curves))
|
|---|
| 1006 | edit_curve(new_line(g->curves, 0), g);
|
|---|
| 1007 | else edit_curve(new_line(g->curves, last(g->curves)->num + 1), g);
|
|---|
| 1008 | } else if (strcmp(inp_str, "title") == 0) {
|
|---|
| 1009 | edit_label(g->title);
|
|---|
| 1010 | } else if (strcmp(inp_str, "legend") == 0) {
|
|---|
| 1011 | edit_legend(g->legend);
|
|---|
| 1012 | } else if (strcmp(inp_str, "x_translate") == 0) {
|
|---|
| 1013 | if (!getfloat(&f)) rejecttoken(); else g->x_translate = f;
|
|---|
| 1014 | } else if (strcmp(inp_str, "y_translate") == 0) {
|
|---|
| 1015 | if (!getfloat(&f)) rejecttoken(); else g->y_translate = f;
|
|---|
| 1016 | } else if (strcmp(inp_str, "string") == 0) {
|
|---|
| 1017 | if (!getint(&num)) {
|
|---|
| 1018 | error_header(); fprintf(stderr, "\"string\" not followed by number\n");
|
|---|
| 1019 | exit(1);
|
|---|
| 1020 | }
|
|---|
| 1021 | s = get_string(g->strings, num);
|
|---|
| 1022 | edit_label(s->s);
|
|---|
| 1023 | } else if (strcmp(inp_str, "newstring") == 0) {
|
|---|
| 1024 | if (first(g->strings) == nil(g->strings))
|
|---|
| 1025 | s = new_string(g->strings, 0);
|
|---|
| 1026 | else s = new_string(g->strings, last(g->strings)->num + 1);
|
|---|
| 1027 | edit_label(s->s);
|
|---|
| 1028 | } else if (strcmp(inp_str, "copystring") == 0 ||
|
|---|
| 1029 | strcmp(inp_str, "copyline") == 0) {
|
|---|
| 1030 | edit_label(do_copy_string(g, gs, all_gs));
|
|---|
| 1031 | } else if (strcmp(inp_str, "inherit_axes") == 0) {
|
|---|
| 1032 | inherit_axes(g, last_graph(g, gs, all_gs));
|
|---|
| 1033 | } else if (strcmp(inp_str, "Y") == 0) {
|
|---|
| 1034 | if (!getfloat(&f)) rejecttoken(); else gs->height = f;
|
|---|
| 1035 | } else if (strcmp(inp_str, "X") == 0) {
|
|---|
| 1036 | if (!getfloat(&f)) rejecttoken(); else gs->width = f;
|
|---|
| 1037 | } else if (strcmp(inp_str, "border") == 0) {
|
|---|
| 1038 | g->border = 1;
|
|---|
| 1039 | } else if (strcmp(inp_str, "noborder") == 0) {
|
|---|
| 1040 | g->border = 0;
|
|---|
| 1041 | } else if (strcmp(inp_str, "clip") == 0) {
|
|---|
| 1042 | g->clip = 1;
|
|---|
| 1043 | } else if (strcmp(inp_str, "noclip") == 0) {
|
|---|
| 1044 | g->clip = 0;
|
|---|
| 1045 | } else {
|
|---|
| 1046 | rejecttoken();
|
|---|
| 1047 | return;
|
|---|
| 1048 | }
|
|---|
| 1049 | }
|
|---|
| 1050 | }
|
|---|
| 1051 |
|
|---|
| 1052 | edit_graphs(gs)
|
|---|
| 1053 | Graphs gs;
|
|---|
| 1054 | {
|
|---|
| 1055 | Graphs the_g;
|
|---|
| 1056 | Graph g, tmp_g;
|
|---|
| 1057 | char inp_str[80];
|
|---|
| 1058 | float f;
|
|---|
| 1059 | int num, i, ok, j;
|
|---|
| 1060 |
|
|---|
| 1061 | the_g = first(gs);
|
|---|
| 1062 | while ( getstring(inp_str) ) {
|
|---|
| 1063 | if (strcmp(inp_str, "graph") == 0) {
|
|---|
| 1064 | if (!getint(&num)) {
|
|---|
| 1065 | error_header(); fprintf(stderr, "\"graph\" not followed by number\n");
|
|---|
| 1066 | exit(1);
|
|---|
| 1067 | }
|
|---|
| 1068 | edit_graph(get_graph(the_g->g, num), the_g, gs);
|
|---|
| 1069 | } else if (strcmp(inp_str, "newgraph") == 0) {
|
|---|
| 1070 | if (first(the_g->g) == nil(the_g->g))
|
|---|
| 1071 | edit_graph(new_graph(the_g->g, 0), the_g, gs);
|
|---|
| 1072 | else edit_graph(new_graph(the_g->g, last(the_g->g)->num + 1), the_g, gs);
|
|---|
| 1073 | } else if (strcmp(inp_str, "copygraph") == 0) {
|
|---|
| 1074 | if (first(the_g->g) == nil(the_g->g))
|
|---|
| 1075 | g = new_graph(the_g->g, 0);
|
|---|
| 1076 | else g = new_graph(the_g->g, last(the_g->g)->num + 1);
|
|---|
| 1077 | if (!getint(&num)) {
|
|---|
| 1078 | rejecttoken();
|
|---|
| 1079 | inherit_axes(g, last_graph(g, the_g, gs));
|
|---|
| 1080 | } else {
|
|---|
| 1081 | ok = 0;
|
|---|
| 1082 | tmp_g = the_g->g;
|
|---|
| 1083 | while(!ok) {
|
|---|
| 1084 | tmp_g = prev(tmp_g);
|
|---|
| 1085 | if (tmp_g == nil(the_g->g) || tmp_g->num < num) {
|
|---|
| 1086 | error_header();
|
|---|
| 1087 | fprintf(stderr, "copygraph: no graph #%d\n", num);
|
|---|
| 1088 | exit(1);
|
|---|
| 1089 | }
|
|---|
| 1090 | ok = (tmp_g->num == num);
|
|---|
| 1091 | }
|
|---|
| 1092 | inherit_axes(g, tmp_g);
|
|---|
| 1093 | }
|
|---|
| 1094 | edit_graph(g, the_g, gs);
|
|---|
| 1095 | } else if (strcmp(inp_str, "Y") == 0) {
|
|---|
| 1096 | if (!getfloat(&f)) rejecttoken(); else the_g->height = f;
|
|---|
| 1097 | } else if (strcmp(inp_str, "X") == 0) {
|
|---|
| 1098 | if (!getfloat(&f)) rejecttoken(); else the_g->width = f;
|
|---|
| 1099 | } else if (strcmp(inp_str, "newpage") == 0) {
|
|---|
| 1100 | new_graphs(gs);
|
|---|
| 1101 | the_g = last(gs);
|
|---|
| 1102 | } else if (strcmp(inp_str, "bbox") == 0) {
|
|---|
| 1103 | for (i = 0; i < 4; i++) {
|
|---|
| 1104 | if (!getint(&j)) {
|
|---|
| 1105 | error_header();
|
|---|
| 1106 | fprintf(stderr, "Bbox definition must have four integers\n");
|
|---|
| 1107 | exit(1);
|
|---|
| 1108 | } else {
|
|---|
| 1109 | the_g->bb[i] = j;
|
|---|
| 1110 | }
|
|---|
| 1111 | }
|
|---|
| 1112 | } else if (strcmp(inp_str, "preamble") == 0) {
|
|---|
| 1113 | if (!getstring(inp_str)) return;
|
|---|
| 1114 | if (strcmp(inp_str, ":") != 0) {
|
|---|
| 1115 | the_g->prefile = 1;
|
|---|
| 1116 | the_g->preamble = (char *) malloc (sizeof(char)*(strlen(inp_str)+1));
|
|---|
| 1117 | strcpy(the_g->preamble, inp_str);
|
|---|
| 1118 | } else {
|
|---|
| 1119 | the_g->prefile = 0;
|
|---|
| 1120 | the_g->preamble = getmultiline();
|
|---|
| 1121 | if (the_g->preamble == CNULL) return;
|
|---|
| 1122 | }
|
|---|
| 1123 | } else if (strcmp(inp_str, "epilogue") == 0) {
|
|---|
| 1124 | if (!getstring(inp_str)) return;
|
|---|
| 1125 | if (strcmp(inp_str, ":") != 0) {
|
|---|
| 1126 | the_g->epifile = 1;
|
|---|
| 1127 | the_g->epilogue = (char *) malloc (sizeof(char)*(strlen(inp_str)+1));
|
|---|
| 1128 | strcpy(the_g->epilogue, inp_str);
|
|---|
| 1129 | } else {
|
|---|
| 1130 | the_g->epifile = 0;
|
|---|
| 1131 | the_g->epilogue = getmultiline();
|
|---|
| 1132 | if (the_g->epilogue == CNULL) return;
|
|---|
| 1133 | }
|
|---|
| 1134 | } else {
|
|---|
| 1135 | error_header(); fprintf(stderr, "Bad token: %s\n", inp_str);
|
|---|
| 1136 | exit(1);
|
|---|
| 1137 | }
|
|---|
| 1138 | }
|
|---|
| 1139 | }
|
|---|
