grconvert/defaults.c

   1 #include <config.h>
   2
   3 #include <math.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8 #include "grconvert.h"
   9
  10 static defaults d_d =
  11 {1, 1, 1, 1.0, 4, 0, 1.0};
  12
  13 /* defaults layout
  14     int color;
  15     int lines;
  16     int linew;
  17     double charsize;
  18     int font;
  19     int fontsrc;
  20     double symsize;
  21 */
  22
  23 static world d_w =
  24 {0.0, 1.0, 0.0, 1.0};
  25
  26 static view d_v =
  27 {0.15, 0.85, 0.15, 0.85};
  28
  29 void set_program_defaults(void)
  30 {
  31     int i;
  32     grdefaults = d_d;
  33     g = (graph *) calloc(maxgraph, sizeof(graph));
  34     for (i = 0; i < maxgraph; i++) {
  35         g[i].p = (plotarr *) calloc(maxplot, sizeof(plotarr));
  36         if (g[i].p == NULL) {
  37             fprintf(stderr,
  38                 "Couldn't allocate memory for sets in graph %d, maxplot = %d, fatal error", i, maxplot);
  39             exit(1);
  40         }
  41         set_default_graph(i);
  42         setdefaultcolors(i);
  43     }
  44     for (i = 0; i < MAXREGION; i++) {
  45         set_region_defaults(i);
  46     }
  47     set_default_annotation();
  48     set_default_string(&timestamp);
  49     alloc_blockdata(maxplot);
  50     timestamp.x = 0.03;
  51     timestamp.y = 0.03;
  52     if (init_scratch_arrays(maxarr)) {
  53         errmsg("Couldn't allocate memory for scratch arrays, don't use them");
  54     }
  55 }
  56
  57 void set_region_defaults(int rno)
  58 {
  59     int j;
  60     rg[rno].active = OFF;
  61     rg[rno].type = 0;
  62     rg[rno].color = grdefaults.color;
  63     rg[rno].lines = grdefaults.lines;
  64     rg[rno].linew = grdefaults.linew;
  65     rg[rno].linkto = (int *) malloc(maxgraph * sizeof(int));
  66     for (j = 0; j < maxgraph; j++) {
  67         rg[rno].linkto[j] = -1;
  68     }
  69     rg[rno].n = 0;
  70     rg[rno].x = rg[rno].y = (double *) NULL;
  71     rg[rno].x1 = rg[rno].y1 = rg[rno].x2 = rg[rno].y2 = 0.0;
  72 }
  73
  74 void set_default_framep(framep * f)
  75 {
  76     f->active = ON;             /* frame on or off */
  77     f->type = 0;                /* frame type */
  78     f->lines = grdefaults.lines;
  79     f->linew = grdefaults.linew;
  80     f->color = grdefaults.color;
  81     f->fillbg = OFF;            /* fill background */
  82     f->bgcolor = 0;             /* background color inside frame */
  83 }
  84
  85 void set_default_world(world * w)
  86 {
  87     memcpy(w, &d_w, sizeof(world));
  88 }
  89
  90 void set_default_view(view * v)
  91 {
  92     memcpy(v, &d_v, sizeof(view));
  93 }
  94
  95 void set_default_string(plotstr * s)
  96 {
  97     s->active = OFF;
  98     s->loctype = VIEW;
  99     s->gno = -1;
 100     s->x = s->y = 0.0;
 101     s->lines = grdefaults.lines;
 102     s->linew = grdefaults.linew;
 103     s->color = grdefaults.color;
 104     s->rot = 0;
 105     s->font = grdefaults.font;
 106     s->just = 0;
 107     s->charsize = grdefaults.charsize;
 108     s->s = (char *) malloc(sizeof(char));
 109     s->s[0] = 0;
 110 }
 111
 112 void set_default_line(linetype * l)
 113 {
 114     l->active = OFF;
 115     l->loctype = VIEW;
 116     l->gno = -1;
 117     l->x1 = l->y1 = l->x2 = l->y2 = 0.0;
 118     l->lines = grdefaults.lines;
 119     l->linew = grdefaults.linew;
 120     l->color = grdefaults.color;
 121     l->arrow = 0;
 122     l->atype = 0;
 123     l->asize = 1.0;
 124 }
 125
 126 void set_default_box(boxtype * b)
 127 {
 128     b->active = OFF;
 129     b->loctype = VIEW;
 130     b->gno = -1;
 131     b->x1 = b->y1 = b->x2 = b->y2 = 0.0;
 132     b->lines = grdefaults.lines;
 133     b->linew = grdefaults.linew;
 134     b->color = grdefaults.color;
 135     b->fill = OFF;
 136     b->fillcolor = 1;
 137     b->fillpattern = 1;
 138 }
 139
 140 void set_default_ellipse(ellipsetype * e)
 141 {
 142     e->active = OFF;
 143     e->loctype = VIEW;
 144     e->gno = -1;
 145     e->x1 = e->y1 = e->x2 = e->y2 = 0.0;
 146     e->lines = grdefaults.lines;
 147     e->linew = grdefaults.linew;
 148     e->color = grdefaults.color;
 149     e->fill = OFF;
 150     e->fillcolor = 1;
 151     e->fillpattern = 1;
 152 }
 153
 154 void set_default_legend(int gno, legend * l)
 155 {
 156     l->active = OFF;
 157     l->loctype = VIEW;
 158     l->layout = 0;
 159     l->vgap = 2;
 160     l->hgap = 1;
 161     l->len = 4;
 162     l->legx = 0.8;
 163     l->legy = 0.8;
 164     l->font = grdefaults.font;
 165     l->charsize = 1.0;
 166     l->color = grdefaults.color;
 167     l->linew = grdefaults.linew;
 168     l->lines = grdefaults.lines;
 169     l->box = OFF;
 170     l->boxfill = OFF;
 171     l->boxfillusing = COLOR;
 172     l->boxfillcolor = 0;
 173     l->boxfillpat = 1;
 174     l->boxlcolor = grdefaults.color;    /* color for symbol */
 175     l->boxlinew = grdefaults.linew;     /* set plot sym line width */
 176     l->boxlines = grdefaults.lines;     /* set plot sym line style */
 177 }
 178
 179 void set_default_plotarr(plotarr * p)
 180 {
 181     int i;
 182     p->active = OFF;            /* active flag */
 183     p->type = XY;               /* dataset type */
 184     p->deact = 0;               /* deactivated set */
 185     p->hotlink = 0;             /* hot linked set */
 186     p->hotfile[0] = 0;          /* hot linked file name */
 187     p->len = 0;                 /* set length */
 188     p->missing = DATASET_MISSING;       /* value for missing data */
 189     p->s = (char **) NULL;      /* pointer to strings */
 190     p->xmin = p->xmax = p->ymin = p->ymax = 0.0;
 191
 192     p->sym = 0;                 /* set plot symbol */
 193     p->symchar = 0;             /* character for symbol */
 194     p->symskip = 0;             /* How many symbols to skip */
 195     p->symfill = 0;             /* Symbol fill type */
 196     p->symdot = 0;              /* Symbol dot in center */
 197     p->symlines = grdefaults.lines;     /* set plot sym line style */
 198     p->symlinew = grdefaults.linew;     /* set plot sym line width */
 199     p->symcolor = -1;           /* color for symbol; -1 means same color as line */
 200     p->symsize = 1.0;           /* size of symbols */
 201
 202     p->font = grdefaults.font;  /* font for strings */
 203     p->format = DECIMAL;        /* format for drawing values */
 204     p->prec = 1;                /* precision for drawing values */
 205     p->just = LEFT;             /* justification for drawing values */
 206     p->where = RIGHT;           /* where to draw values */
 207     p->valsize = 1.0;           /* char size for drawing values */
 208
 209     p->lines = grdefaults.lines;
 210     p->linew = grdefaults.linew;
 211     p->color = grdefaults.color;
 212     p->lineskip = 0;            /* How many points to skip when drawing lines */
 213
 214     p->fill = 0;                /* fill type */
 215     p->fillusing = COLOR;       /* fill using color or pattern */
 216     p->fillcolor = 1;           /* fill color */
 217     p->fillpattern = 0;         /* fill pattern */
 218
 219     p->errbar = -1;             /* if type is _DX, _DY, _DXDY and errbar =
 220                                  * TRUE */
 221     p->errbarxy = BOTH;         /* type of error bar */
 222     p->errbar_lines = grdefaults.lines; /* error bar line width */
 223     p->errbar_linew = grdefaults.linew; /* error bar line style */
 224     p->errbar_riser = ON;       /* connecting line between error limits */
 225     p->errbar_riser_linew = 1;  /* connecting line between error limits line
 226                                  * width */
 227     p->errbar_riser_lines = 1;  /* connecting line between error limits line
 228                                  * style */
 229
 230     p->errbarper = 1.0;         /* length of error bar */
 231     p->hilowper = 1.0;          /* length of hi-low */
 232
 233     p->density_plot = 0;        /* if type is XYZ then density_plot  = 1 */
 234     p->zmin = p->zmax = 0.0;    /* min max for density plots */
 235
 236     p->comments[0] = 0;         /* how did this set originate */
 237     p->lstr[0] = 0;             /* legend */
 238
 239     for (i = 0; i < MAX_SET_COLS; i++) {
 240         p->ex[i] = NULL;
 241         p->emin[i] = 0.0;       /* min for each column */
 242         p->emax[i] = 0.0;       /* max for each column */
 243         p->imin[i] = 0;         /* min loc for each column */
 244         p->imax[i] = 0;         /* max loc for each column */
 245     }
 246     p->ep = NULL;               /* EditPoints pointer */
 247 }
 248
 249 void set_default_velocityp(velocityp * vp)
 250 {
 251     vp->active = OFF;
 252     vp->type = 0;
 253     vp->loctype = VIEW;
 254     vp->velx = 0.8;
 255     vp->vely = 0.7;
 256     vp->lines = grdefaults.lines;
 257     vp->linew = grdefaults.linew;
 258     vp->color = grdefaults.color;
 259     set_default_string(&(vp->vstr));
 260     vp->arrowtype = 0;
 261     vp->vscale = 1.0;
 262     vp->units = 0;
 263     vp->userlength = 1.0;
 264 }
 265
 266 void set_default_graph(int gno)
 267 {
 268     int i;
 269
 270     g[gno].active = OFF;
 271     g[gno].hidden = FALSE;
 272     g[gno].label = OFF;
 273     g[gno].type = XY;
 274     g[gno].auto_type = AUTO;
 275     g[gno].autoscale = 0;
 276     g[gno].noautoscale = 0;
 277     g[gno].revx = FALSE;
 278     g[gno].revy = FALSE;
 279     g[gno].ws_top = 1;
 280     g[gno].ws[0].w.xg1=g[gno].ws[0].w.xg2=g[gno].ws[0].w.yg1=g[gno].ws[0].w.yg2=0;
 281         g[gno].curw = 0;
 282     g[gno].maxplot = maxplot;
 283     g[gno].dsx = g[gno].dsy = 0.0;      /* locator props */
 284     g[gno].pointset = FALSE;
 285     g[gno].pt_type = 0;
 286     g[gno].fx = GENERAL;
 287     g[gno].fy = GENERAL;
 288     g[gno].px = 6;
 289     g[gno].py = 6;
 290     g[gno].barwid = 0.85;
 291     g[gno].sbarwid = 0.75;
 292     set_default_ticks(&g[gno].t[0], X_AXIS);
 293     set_default_ticks(&g[gno].t[1], Y_AXIS);
 294     set_default_ticks(&g[gno].t[2], ZX_AXIS);
 295     set_default_ticks(&g[gno].t[3], ZY_AXIS);
 296     set_default_framep(&g[gno].f);
 297     set_default_world(&g[gno].w);
 298     set_default_view(&g[gno].v);
 299     g[gno].rt.xg1 = 1.0;
 300     g[gno].rt.yg1 = 2.0 * M_PI;
 301     set_default_legend(gno, &g[gno].l);
 302     set_default_string(&g[gno].labs.title);
 303     g[gno].labs.title.charsize = 1.5;
 304     set_default_string(&g[gno].labs.stitle);
 305     g[gno].labs.stitle.charsize = 1.0;
 306     for (i = 0; i < maxplot; i++) {
 307         set_default_plotarr(&g[gno].p[i]);
 308     }
 309     set_default_velocityp(&g[gno].vp);
 310 }
 311
 312 void realloc_plots(int maxplot)
 313 {
 314     int i, j;
 315     for (i = 0; i < maxgraph; i++) {
 316         g[i].p = (plotarr *) realloc(g[i].p, maxplot * sizeof(plotarr));
 317         for (j = g[i].maxplot; j < maxplot; j++) {
 318             g[i].p[j].len = 0;
 319             set_default_plotarr(&g[i].p[j]);
 320         }
 321         g[i].maxplot = maxplot;
 322     }
 323 }
 324
 325 void realloc_graph_plots(int gno, int maxplot)
 326 {
 327     int j;
 328     g[gno].p = (plotarr *) realloc(g[gno].p, maxplot * sizeof(plotarr));
 329     for (j = g[gno].maxplot; j < maxplot; j++) {
 330         g[gno].p[j].len = 0;
 331         set_default_plotarr(&g[gno].p[j]);
 332     }
 333     g[gno].maxplot = maxplot;
 334 }
 335
 336 void realloc_graphs(void)
 337 {
 338     int j;
 339
 340     g = (graph *) realloc(g, maxgraph * sizeof(graph));
 341     for (j = MAXGRAPH; j < maxgraph; j++) {
 342         g[j].p = (plotarr *) calloc(maxplot, sizeof(plotarr));
 343         set_default_graph(j);
 344     }
 345 }
 346
 347 void set_default_annotation(void)
 348 {
 349     int i;
 350
 351     lines = (linetype *) malloc(maxlines * sizeof(linetype));
 352     boxes = (boxtype *) malloc(maxboxes * sizeof(boxtype));
 353     pstr = (plotstr *) malloc(maxstr * sizeof(plotstr));
 354     ellip = (ellipsetype *) malloc(maxellipses * sizeof(ellipsetype));
 355
 356     for (i = 0; i < maxboxes; i++) {
 357         set_default_box(&boxes[i]);
 358     }
 359     for (i = 0; i < maxlines; i++) {
 360         set_default_line(&lines[i]);
 361     }
 362     for (i = 0; i < maxellipses; i++) {
 363         set_default_ellipse(&ellip[i]);
 364     }
 365     for (i = 0; i < maxstr; i++) {
 366         set_default_string(&pstr[i]);
 367     }
 368 }
 369
 370 void set_default_ticks(tickmarks * t, int a)
 371 {
 372     int i;
 373
 374     t->axis = a;
 375     switch (a) {
 376     case X_AXIS:
 377     case Y_AXIS:
 378         t->active = ON;
 379         t->alt = OFF;
 380         t->tl_flag = ON;
 381         t->t_flag = ON;
 382         break;
 383     case ZX_AXIS:
 384     case ZY_AXIS:
 385         t->active = ON;
 386         t->alt = OFF;
 387         t->tl_flag = OFF;
 388         t->t_flag = OFF;
 389         break;
 390     }
 391     set_default_string(&t->label);
 392     t->tmin = 0.0;
 393     t->tmax = 1.0;
 394     t->tmajor = 0.5;
 395     t->tminor = 0.25;
 396     t->offsx = 0.0;
 397     t->offsy = 0.0;
 398     t->label_layout = PARA;
 399     t->label_place = AUTO;
 400     t->tl_type = AUTO;
 401     t->tl_layout = HORIZONTAL;
 402     t->tl_loc = ON;
 403     t->tl_sign = NORMAL;
 404     t->tl_prec = 1;
 405     t->tl_format = DECIMAL;
 406     t->tl_angle = 0;
 407     t->tl_just = (a % 2) ? RIGHT : CENTER;
 408     t->tl_skip = 0;
 409     t->tl_staggered = 0;
 410     t->tl_starttype = AUTO;
 411     t->tl_stoptype = AUTO;
 412     t->tl_start = 0.0;
 413     t->tl_stop = 0.0;
 414     t->tl_op = (a % 2) ? LEFT : BOTTOM;
 415     t->tl_vgap = 1.0;
 416     t->tl_hgap = 1.0;
 417     t->tl_font = grdefaults.font;
 418     t->tl_charsize = 1.0;
 419     t->tl_linew = grdefaults.linew;
 420     t->tl_color = grdefaults.color;
 421     t->tl_appstr[0] = 0;
 422     t->tl_prestr[0] = 0;
 423     t->t_type = AUTO;
 424     t->t_mflag = ON;
 425     t->t_integer = OFF;
 426     t->t_num = 6;
 427     t->t_inout = IN;
 428     t->t_log = OFF;
 429     t->t_op = BOTH;
 430     t->t_size = 1.0;
 431     t->t_msize = 0.5;
 432     t->t_drawbar = OFF;
 433     t->t_drawbarcolor = grdefaults.color;
 434     t->t_drawbarlines = grdefaults.lines;
 435     t->t_drawbarlinew = grdefaults.linew;
 436     t->t_gridflag = OFF;
 437     t->t_mgridflag = OFF;
 438     t->t_color = grdefaults.color;
 439     t->t_lines = grdefaults.lines;
 440     t->t_linew = grdefaults.linew;
 441     t->t_mcolor = grdefaults.color;
 442     t->t_mlines = grdefaults.lines;
 443     t->t_mlinew = grdefaults.linew;
 444     t->t_spec = 0;
 445     for (i = 0; i < MAX_TICK_LABELS; i++) {
 446         t->t_specloc[i] = 0.0;
 447         t->t_speclab[i].s = NULL;
 448     }
 449 }
 450
 451 static int default_color[MAXPLOT] =
 452 {
 453     1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
 454     11, 12, 13, 14, 15,
 455     1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
 456     11, 12, 13, 14, 15
 457 };
 458
 459 void setdefaultcolors(int gno)
 460 {
 461     int i;
 462     for (i = 0; i < g[gno].maxplot; i++) {
 463         g[gno].p[i].color = default_color[i % MAXPLOT];
 464     }
 465 }
 466
 467 void kill_blockdata(void)
 468 {
 469     int j;
 470     if (blockdata != NULL) {
 471         for (j = 0; j < maxblock; j++) {
 472             cxfree(blockdata[j]);
 473         }
 474     }
 475 }
 476
 477
 478 void alloc_blockdata(int ncols)
 479 {
 480     int j;
 481     if (blockdata != NULL) {
 482         kill_blockdata();
 483     }
 484     if (ncols < MAXPLOT) {
 485         ncols = MAXPLOT;
 486     }
 487     blockdata = (double **) malloc(ncols * sizeof(double *));
 488     if (blockdata != NULL) {
 489         maxblock = ncols;
 490         for (j = 0; j < maxblock; j++) {
 491             blockdata[j] = NULL;
 492         }
 493     } else {
 494         errmsg("alloc_blockdata(): Error, unable to allocate memory for block data");
 495     }
 496 }
 497
 498 int init_array(double **a, int n)
 499 {
 500     if (*a != NULL) {
 501         *a = (double *) realloc(*a, n * sizeof(double));
 502     } else {
 503         *a = (double *) calloc(n, sizeof(double));
 504     }
 505     return *a == NULL ? 1 : 0;
 506 }
 507
 508 int init_scratch_arrays(int n)
 509 {
 510     if (!init_array(&ax, n)) {
 511         if (!init_array(&bx, n)) {
 512             if (!init_array(&cx, n)) {
 513                 if (!init_array(&dx, n)) {
 514                     maxarr = n;
 515                     return 0;
 516                 }
 517                 free(cx);
 518             }
 519             free(bx);
 520         }
 521         free(ax);
 522     }
 523     return 1;
 524 }
 525