Annotation of OpenXM_contrib/gnuplot/graphics.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: graphics.c,v 1.138 1998/06/18 14:55:08 ddenholm Exp $";
! 3: #endif
! 4:
! 5: /* GNUPLOT - graphics.c */
! 6:
! 7: /*[
! 8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
! 9: *
! 10: * Permission to use, copy, and distribute this software and its
! 11: * documentation for any purpose with or without fee is hereby granted,
! 12: * provided that the above copyright notice appear in all copies and
! 13: * that both that copyright notice and this permission notice appear
! 14: * in supporting documentation.
! 15: *
! 16: * Permission to modify the software is granted, but not the right to
! 17: * distribute the complete modified source code. Modifications are to
! 18: * be distributed as patches to the released version. Permission to
! 19: * distribute binaries produced by compiling modified sources is granted,
! 20: * provided you
! 21: * 1. distribute the corresponding source modifications from the
! 22: * released version in the form of a patch file along with the binaries,
! 23: * 2. add special version identification to distinguish your version
! 24: * in addition to the base release version number,
! 25: * 3. provide your name and address as the primary contact for the
! 26: * support of your modified version, and
! 27: * 4. retain our contact information in regard to use of the base
! 28: * software.
! 29: * Permission to distribute the released version of the source code along
! 30: * with corresponding source modifications in the form of a patch file is
! 31: * granted with same provisions 2 through 4 for binary distributions.
! 32: *
! 33: * This software is provided "as is" without express or implied warranty
! 34: * to the extent permitted by applicable law.
! 35: ]*/
! 36:
! 37:
! 38: #include "plot.h"
! 39: #include "setshow.h"
! 40:
! 41: /* key placement is calculated in boundary, so we need file-wide variables
! 42: * To simplify adjustments to the key, we set all these once [depends on
! 43: * key_reverse] and use them throughout.
! 44: */
! 45:
! 46: /*{{{ local and global variables */
! 47: static int key_sample_width; /* width of line sample */
! 48: static int key_sample_left; /* offset from x for left of line sample */
! 49: static int key_sample_right; /* offset from x for right of line sample */
! 50: static int key_point_offset; /* offset from x for point sample */
! 51: static int key_text_left; /* offset from x for left-justified text */
! 52: static int key_text_right; /* offset from x for right-justified text */
! 53: static int key_size_left; /* size of left bit of key (text or sample, depends on key_reverse) */
! 54: static int key_size_right; /* size of right part of key (including padding) */
! 55:
! 56: /* I think the following should also be static ?? */
! 57:
! 58: static int key_xl, key_xr, key_yt, key_yb; /* boundarys for key field */
! 59: static int max_ptitl_len = 0; /* max length of plot-titles (keys) */
! 60: static int ktitl_lines = 0; /* no lines in key_title (key header) */
! 61: static int ptitl_cnt; /* count keys with len > 0 */
! 62: static int key_cols; /* no cols of keys */
! 63: static int key_rows, key_col_wth, yl_ref;
! 64:
! 65:
! 66: /* penalty for doing tics by callback in gen_tics is need for
! 67: * global variables to communicate with the tic routines
! 68: * Dont need to be arrays for this
! 69: */
! 70: static int tic_start, tic_direction, tic_text, rotate_tics, tic_hjust, tic_vjust, tic_mirror;
! 71:
! 72: /* set by tic_callback - how large to draw polar radii */
! 73: static double largest_polar_circle;
! 74:
! 75: /* either xformat etc or invented time format
! 76: * index with FIRST_X_AXIS etc
! 77: * global because used in gen_tics, which graph3d also uses
! 78: */
! 79: char ticfmt[8][MAX_ID_LEN+1]; /* HBB 990106: fix buffer overrun */
! 80: int timelevel[8];
! 81: double ticstep[8];
! 82:
! 83: static int xlablin, x2lablin, ylablin, y2lablin, titlelin, xticlin, x2ticlin;
! 84:
! 85: static int key_entry_height; /* bigger of t->v_size, pointsize*t->v_tick */
! 86: static int p_width, p_height; /* pointsize * { t->h_tic | t->v_tic } */
! 87:
! 88:
! 89: /* there are several things on right of plot - key, y2tics and y2label
! 90: * when working out boundary, save posn of y2label for later...
! 91: * Same goes for x2label.
! 92: * key posn is also stored in key_xl, and tics go at xright
! 93: */
! 94: static int ylabel_x, y2label_x, xlabel_y, x2label_y, title_y, time_y, time_x;
! 95: static int ylabel_y, y2label_y, xtic_y, x2tic_y, ytic_x, y2tic_x;
! 96: /*}}} */
! 97:
! 98: /*{{{ static fns and local macros */
! 99: static void plot_impulses __PROTO((struct curve_points * plot, int yaxis_x,
! 100: int xaxis_y));
! 101: static void plot_lines __PROTO((struct curve_points * plot));
! 102: static void plot_points __PROTO((struct curve_points * plot));
! 103: static void plot_dots __PROTO((struct curve_points * plot));
! 104: static void plot_bars __PROTO((struct curve_points * plot));
! 105: static void plot_boxes __PROTO((struct curve_points * plot, int xaxis_y));
! 106: static void plot_vectors __PROTO((struct curve_points * plot));
! 107: static void plot_f_bars __PROTO((struct curve_points * plot));
! 108: static void plot_c_bars __PROTO((struct curve_points * plot));
! 109:
! 110: static void edge_intersect __PROTO((struct coordinate GPHUGE * points, int i,
! 111: double *ex, double *ey));
! 112: static int two_edge_intersect __PROTO((struct coordinate GPHUGE * points,
! 113: int i, double *lx, double *ly));
! 114: static TBOOLEAN two_edge_intersect_steps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly));
! 115:
! 116: static void plot_steps __PROTO((struct curve_points * plot)); /* JG */
! 117: static void plot_fsteps __PROTO((struct curve_points * plot)); /* HOE */
! 118: static void plot_histeps __PROTO((struct curve_points * plot)); /* CAC */
! 119: static void histeps_horizontal __PROTO((int *xl, int *yl, double x1, double x2,
! 120: double y)); /* CAC */
! 121: static void histeps_vertical __PROTO((int *xl, int *yl, double x, double y1,
! 122: double y2)); /* CAC */
! 123: static void edge_intersect_steps __PROTO((struct coordinate GPHUGE * points,
! 124: int i, double *ex, double *ey)); /* JG */
! 125: static void edge_intersect_fsteps __PROTO((struct coordinate GPHUGE * points,
! 126: int i, double *ex, double *ey)); /* HOE */
! 127: static TBOOLEAN two_edge_intersect_steps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly)); /* JG */
! 128: static TBOOLEAN two_edge_intersect_fsteps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly));
! 129:
! 130: static double LogScale __PROTO((double coord, int is_log, double log_base_log,
! 131: char *what, char *axis));
! 132: static double dbl_raise __PROTO((double x, int y));
! 133: static void boundary __PROTO((int scaling, struct curve_points * plots,
! 134: int count));
! 135: static double make_tics __PROTO((int axis, int guide));
! 136:
! 137: /* widest2d_callback keeps longest so far in here */
! 138: static int widest_tic;
! 139:
! 140: static void widest2d_callback __PROTO((int axis, double place, char *text,
! 141: struct lp_style_type grid));
! 142: static void ytick2d_callback __PROTO((int axis, double place, char *text,
! 143: struct lp_style_type grid));
! 144: static void xtick2d_callback __PROTO((int axis, double place, char *text,
! 145: struct lp_style_type grid));
! 146: static void map_position __PROTO((struct position * pos, unsigned int *x,
! 147: unsigned int *y, char *what));
! 148: static void mant_exp __PROTO((double log_base, double x, int scientific,
! 149: double *m, int *p));
! 150: static void gprintf __PROTO((char *dest, size_t count, char *format,
! 151: double log_base, double x));
! 152:
! 153: #if defined(sun386) || defined(AMIGA_SC_6_1)
! 154: static double CheckLog __PROTO((TBOOLEAN is_log, double base_log, double x));
! 155: #endif
! 156:
! 157: /* for plotting error bars
! 158: * half the width of error bar tic mark
! 159: */
! 160: #define ERRORBARTIC (t->h_tic/2)
! 161:
! 162: /*
! 163: * The Amiga SAS/C 6.2 compiler moans about macro envocations causing
! 164: * multiple calls to functions. I converted these macros to inline
! 165: * functions coping with the problem without loosing speed.
! 166: * If your compiler supports __inline, you should add it to the
! 167: * #ifdef directive
! 168: * (MGR, 1993)
! 169: */
! 170:
! 171: #ifdef AMIGA_SC_6_1
! 172: GP_INLINE static TBOOLEAN i_inrange(int z, int min, int max)
! 173: {
! 174: return ((min < max) ? ((z >= min) && (z <= max)) : ((z >= max) && (z <= min)));
! 175: }
! 176:
! 177: GP_INLINE static double f_max(double a, double b)
! 178: {
! 179: return (GPMAX(a, b));
! 180: }
! 181:
! 182: GP_INLINE static double f_min(double a, double b)
! 183: {
! 184: return (GPMIN(a, b));
! 185: }
! 186:
! 187: #else
! 188: #define f_max(a,b) GPMAX((a),(b))
! 189: #define f_min(a,b) GPMIN((a),(b))
! 190: #define i_inrange(z,a,b) inrange((z),(a),(b))
! 191: #endif
! 192:
! 193: /* True if a and b have the same sign or zero (positive or negative) */
! 194: #define samesign(a,b) ((a) * (b) >= 0)
! 195: /*}}} */
! 196:
! 197: /*{{{ more variables */
! 198: /* Define the boundary of the plot
! 199: * These are computed at each call to do_plot, and are constant over
! 200: * the period of one do_plot. They actually only change when the term
! 201: * type changes and when the 'set size' factors change.
! 202: * - no longer true, for 'set key out' or 'set key under'. also depend
! 203: * on tic marks and multi-line labels.
! 204: * They are shared with graph3d.c since we want to use its draw_clip_line()
! 205: */
! 206: int xleft, xright, ybot, ytop;
! 207:
! 208:
! 209: /* we make a local copy of the 'key' variable so that if something
! 210: * goes wrong, we can switch it off temporarily
! 211: */
! 212:
! 213: static int lkey;
! 214:
! 215: /* First attempt at double axes...
! 216: * x_min etc are now accessed from a global array min_array[], max_array[]
! 217: * put the scale factors into a similar array
! 218: * for convenience in this first attack on double axes, just define x_min etc
! 219: * since code already uses x_min, etc Eventually it will be done properly
! 220: */
! 221:
! 222:
! 223: extern double min_array[], max_array[];
! 224: extern int auto_array[];
! 225:
! 226: extern int log_array[];
! 227: extern double base_array[], log_base_array[];
! 228:
! 229: static int x_axis = FIRST_X_AXIS, y_axis = FIRST_Y_AXIS; /* current axes */
! 230:
! 231: static double scale[AXIS_ARRAY_SIZE]; /* scale factors for mapping for each axis */
! 232:
! 233: /* BODGES BEFORE I FIX IT UP */
! 234: #define x_min min_array[x_axis]
! 235: #define x_max max_array[x_axis]
! 236: #define y_min min_array[y_axis]
! 237: #define y_max max_array[y_axis]
! 238:
! 239: /* And the functions to map from user to terminal coordinates */
! 240: /* maps floating point x to screen */
! 241: #define map_x(x) (int)(xleft+(x-min_array[x_axis])*scale[x_axis]+0.5)
! 242: /* same for y */
! 243: #define map_y(y) (int)(ybot +(y-min_array[y_axis])*scale[y_axis]+0.5)
! 244:
! 245: /* (DFK) Watch for cancellation error near zero on axes labels */
! 246: /* less than one hundredth of a tic mark */
! 247: #define SIGNIF (0.01)
! 248: #define CheckZero(x,tic) (fabs(x) < ((tic) * SIGNIF) ? 0.0 : (x))
! 249: #define NearlyEqual(x,y,tic) (fabs((x)-(y)) < ((tic) * SIGNIF))
! 250: /*}}} */
! 251:
! 252: /*{{{ CheckLog() */
! 253: /* (DFK) For some reason, the Sun386i compiler screws up with the CheckLog
! 254: * macro, so I write it as a function on that machine.
! 255: *
! 256: * Amiga SAS/C 6.2 thinks it will do too much work calling functions in
! 257: * macro arguments twice, thus I inline theese functions. (MGR, 1993)
! 258: * If your compiler doesn't handle those macros correctly, you should
! 259: * also subscribe here. Even without inlining you gain speed with log plots
! 260: */
! 261: #if defined(sun386) || defined(AMIGA_SC_6_1)
! 262: GP_INLINE static double CheckLog(is_log, base_log, x)
! 263: TBOOLEAN is_log;
! 264: double base_log;
! 265: double x;
! 266: {
! 267: if (is_log)
! 268: return (pow(base_log, x));
! 269: else
! 270: return (x);
! 271: }
! 272: #else
! 273: /* (DFK) Use 10^x if logscale is in effect, else x */
! 274: #define CheckLog(is_log, base_log, x) ((is_log) ? pow(base_log, (x)) : (x))
! 275: #endif /* sun386 || SAS/C */
! 276: /*}}} */
! 277:
! 278: /*{{{ LogScale() */
! 279: static double LogScale(coord, is_log, log_base_log, what, axis)
! 280: double coord; /* the value */
! 281: TBOOLEAN is_log; /* is this axis in logscale? */
! 282: double log_base_log; /* if so, the log of its base */
! 283: char *what; /* what is the coord for? */
! 284: char *axis; /* which axis is this for ("x" or "y")? */
! 285: {
! 286: if (is_log) {
! 287: if (coord <= 0.0) {
! 288: char errbuf[100]; /* place to write error message */
! 289: (void) sprintf(errbuf, "%s has %s coord of %g; must be above 0 for log scale!",
! 290: what, axis, coord);
! 291: graph_error(errbuf);
! 292: } else
! 293: return (log(coord) / log_base_log);
! 294: }
! 295: return (coord);
! 296: }
! 297: /*}}} */
! 298:
! 299: /*{{{ graph_error() */
! 300: /* handle errors during graph-plot in a consistent way */
! 301: void graph_error(text)
! 302: char *text;
! 303: {
! 304: multiplot = FALSE;
! 305: term_end_plot();
! 306: int_error(text, NO_CARET);
! 307: }
! 308:
! 309: /*}}} */
! 310:
! 311:
! 312: /*{{{ fixup_range() */
! 313: /*
! 314: * === SYNOPSIS ===
! 315: *
! 316: * This function checks whether the data and/or plot range in a given axis
! 317: * is too small (which would cause divide-by-zero and/or infinite-loop
! 318: * problems later on). If so,
! 319: * - if autoscaling is in effect for this axis, we widen the range
! 320: * - otherwise, we abort with a call to int_error() (which prints out
! 321: * a suitable error message, then (hopefully) aborts this command and
! 322: * returns to the command prompt or whatever).
! 323: *
! 324: *
! 325: * === HISTORY AND DESIGN NOTES ===
! 326: *
! 327: * 1998 Oct 4, Jonathan Thornburg <jthorn@galileo.thp.univie.ac.at>
! 328: *
! 329: * This function used to be a (long) macro FIXUP_RANGE(AXIS, WHICH)
! 330: * which was (identically!) defined in plot2d.c and plot3d.c . As
! 331: * well as now being a function instead of a macro, the logic is also
! 332: * changed: The "too small" range test no longer depends on 'set zero'
! 333: * and is now properly scaled relative to the data magnitude.
! 334: *
! 335: * The key question in designing this function is the policy for just how
! 336: * much to widen the data range by, as a function of the data magnitude.
! 337: * This is to some extent a matter of taste. IMHO the key criterion is
! 338: * that (at least) all of the following should (a) not infinite-loop, and
! 339: * (b) give correct plots, regardless of the 'set zero' setting:
! 340: * plot 6.02e23 # a huge number >> 1 / FP roundoff level
! 341: * plot 3 # a "reasonable-sized" number
! 342: * plot 1.23e-12 # a small number still > FP roundoff level
! 343: * plot 1.23e-12 * sin(x) # a small function still > FP roundoff level
! 344: * plot 1.23e-45 # a tiny number << FP roundoff level
! 345: * plot 1.23e-45 * sin(x) # a tiny function << FP roundoff level
! 346: * plot 0 # or (more commonly) a data file of all zeros
! 347: * That is, IMHO gnuplot should *never* infinite-loop, and it should *never*
! 348: * producing an incorrect or misleading plot. In contrast, the old code
! 349: * would infinite-loop on most of these examples with 'set zero 0.0' in
! 350: * effect, or would plot the small-amplitude sine waves as the zero function
! 351: * with 'zero' set larger than the sine waves' amplitude.
! 352: *
! 353: * The current code plots all the above examples correctly and without
! 354: * infinite looping.
! 355: *
! 356: *
! 357: * === USAGE ===
! 358: *
! 359: * Arguments:
! 360: * axis = (in) An integer specifying which axis (x1, x2, y1, y2, z, etc)
! 361: * we should do our stuff for. We use this argument as an
! 362: * index into the global arrays {min,max,auto}_array . In
! 363: * practice this argument will typically be one of the constants
! 364: * {FIRST,SECOND}_{X,Y,Z}_AXIS defined in plot.h.
! 365: * axis_name --> (in) This argument should point to the character string
! 366: * name corresponding to axis , e.g. "x", "y2", etc.
! 367: * We use this (only) in formatting warning/error messages.
! 368: *
! 369: * Global Variables:
! 370: * auto_array[axis] = (in) (defined in command.c) Bit-flags which tell
! 371: * [in some manner I don't fully understand :=( ]
! 372: * whether and/or how autoscaling is in effect for
! 373: * this axis.
! 374: * {min,max}_array = (in out) (defined in command.c) The data ranges which
! 375: * this function manipulates.
! 376: * c_token = (in) (defined in plot.h) Used in formatting an error message.
! 377: *
! 378: * Bugs:
! 379: * - If strlen(axis_name) > strlen("%s") , we may overflow an
! 380: * error-message buffer, which would be A Bad Thing. Caveat caller...
! 381: */
! 382: void fixup_range(axis, axis_name)
! 383: int axis;
! 384: char *axis_name;
! 385: {
! 386: #define MAX_AXIS_NAME_LEN 2 /* max legal strlen(axis_name) */
! 387:
! 388: /* These two macro definitions set the range-widening policy: */
! 389: #define FIXUP_RANGE__WIDEN_ZERO_ABS 1.0 /* widen [0:0] by
! 390: +/- this absolute amount */
! 391: #define FIXUP_RANGE__WIDEN_NONZERO_REL 0.01 /* widen [nonzero:nonzero] by
! 392: -/+ this relative amount */
! 393:
! 394: double dmin = min_array[axis];
! 395: double dmax = max_array[axis];
! 396: if (dmax - dmin == 0.0) {
! 397: /* empty range */
! 398: if (auto_array[axis]) {
! 399: /* range came from autoscaling ==> widen it */
! 400: double widen = (dmax == 0.0)
! 401: ? FIXUP_RANGE__WIDEN_ZERO_ABS
! 402: : FIXUP_RANGE__WIDEN_NONZERO_REL * dmax;
! 403: fprintf(stderr,
! 404: "Warning: empty %s range [%g:%g], ",
! 405: axis_name, dmin, dmax);
! 406: min_array[axis] -= widen;
! 407: max_array[axis] += widen;
! 408: fprintf(stderr,
! 409: "adjusting to [%g:%g]\n",
! 410: min_array[axis], max_array[axis]);
! 411: } else {
! 412: /* user has explicitly set the range */
! 413: /* (to something empty) ==> we're in trouble */
! 414: char msg_buffer[MAX_LINE_LEN + 1];
! 415: sprintf(msg_buffer, "Can't plot with an empty %s range!", axis_name);
! 416: int_error(msg_buffer, c_token); /* never returns */
! 417: }
! 418: }
! 419: }
! 420:
! 421: /*}}} */
! 422:
! 423:
! 424: /*{{{ widest2d_callback() */
! 425: /* we determine widest tick label by getting gen_ticks to call this
! 426: * routine with every label
! 427: */
! 428:
! 429: static void widest2d_callback(axis, place, text, grid)
! 430: int axis;
! 431: double place;
! 432: char *text;
! 433: struct lp_style_type grid;
! 434: {
! 435: int len = label_width(text, NULL);
! 436: if (len > widest_tic)
! 437: widest_tic = len;
! 438: }
! 439: /*}}} */
! 440:
! 441:
! 442: /*{{{ boundary() */
! 443: /* borders of plotting area
! 444: * computed once on every call to do_plot
! 445: *
! 446: * The order in which things is done is getting pretty critical:
! 447: * ytop depends on title, x2label, ylabels (if no rotated text)
! 448: * ybot depends on key, if TUNDER
! 449: * once we have these, we can setup the y1 and y2 tics and the
! 450: * only then can we calculate xleft and xright
! 451: * xright depends also on key TRIGHT
! 452: * then we can do x and x2 tics
! 453: *
! 454: * For set size ratio ..., everything depends on everything else...
! 455: * not really a lot we can do about that, so we lose if the plot has to
! 456: * be reduced vertically. But the chances are the
! 457: * change will not be very big, so the number of tics will not
! 458: * change dramatically.
! 459: *
! 460: * Margin computation redone by Dick Crawford (rccrawford@lanl.gov) 4/98
! 461: */
! 462:
! 463: static void boundary(scaling, plots, count)
! 464: TBOOLEAN scaling; /* TRUE if terminal is doing the scaling */
! 465: struct curve_points *plots;
! 466: int count;
! 467: {
! 468: int ytlen;
! 469: int yticlin = 0, y2ticlin = 0, timelin = 0;
! 470:
! 471: register struct termentry *t = term;
! 472: int key_h, key_w;
! 473: int can_rotate = (*t->text_angle) (1);
! 474:
! 475: int xtic_textheight; /* height of xtic labels */
! 476: int x2tic_textheight; /* height of x2tic labels */
! 477: int title_textheight; /* height of title */
! 478: int xlabel_textheight; /* height of xlabel */
! 479: int x2label_textheight; /* height of x2label */
! 480: int timetop_textheight; /* height of timestamp (if at top) */
! 481: int timebot_textheight; /* height of timestamp (if at bottom) */
! 482: int ylabel_textheight; /* height of (unrotated) ylabel */
! 483: int y2label_textheight; /* height of (unrotated) y2label */
! 484: int ylabel_textwidth; /* width of (rotated) ylabel */
! 485: int y2label_textwidth; /* width of (rotated) y2label */
! 486: int timelabel_textwidth; /* width of timestamp */
! 487: int ytic_textwidth; /* width of ytic labels */
! 488: int y2tic_textwidth; /* width of y2tic labels */
! 489: int x2tic_height; /* 0 for tic_in or no x2tics, ticscale*v_tic otherwise */
! 490: int xtic_height;
! 491: int ytic_width;
! 492: int y2tic_width;
! 493:
! 494: /* figure out which rotatable items are to be rotated
! 495: * (ylabel and y2label are rotated if possible) */
! 496: int vertical_timelabel = can_rotate && timelabel_rotate;
! 497: int vertical_xtics = can_rotate && rotate_xtics;
! 498: int vertical_x2tics = can_rotate && rotate_x2tics;
! 499: int vertical_ytics = can_rotate && rotate_ytics;
! 500: int vertical_y2tics = can_rotate && rotate_y2tics;
! 501:
! 502: lkey = key; /* but we may have to disable it later */
! 503:
! 504: xticlin = ylablin = y2lablin = xlablin = x2lablin = titlelin = 0;
! 505:
! 506: /*{{{ count lines in labels and tics */
! 507: if (*title.text)
! 508: label_width(title.text, &titlelin);
! 509: if (*xlabel.text)
! 510: label_width(xlabel.text, &xlablin);
! 511: if (*x2label.text)
! 512: label_width(x2label.text, &x2lablin);
! 513: if (*ylabel.text)
! 514: label_width(ylabel.text, &ylablin);
! 515: if (*y2label.text)
! 516: label_width(y2label.text, &y2lablin);
! 517: if (xtics)
! 518: label_width(xformat, &xticlin);
! 519: if (x2tics)
! 520: label_width(x2format, &x2ticlin);
! 521: if (ytics)
! 522: label_width(yformat, &yticlin);
! 523: if (y2tics)
! 524: label_width(y2format, &y2ticlin);
! 525: if (*timelabel.text)
! 526: label_width(timelabel.text, &timelin);
! 527: /*}}} */
! 528:
! 529: /*{{{ preliminary ytop calculation */
! 530:
! 531: /* first compute heights of things to be written in the margin */
! 532:
! 533: /* title */
! 534: if (titlelin)
! 535: title_textheight = (int) ((titlelin + title.yoffset + 1) * (t->v_char));
! 536: else
! 537: title_textheight = 0;
! 538:
! 539: /* x2label */
! 540: if (x2lablin) {
! 541: x2label_textheight = (int) ((x2lablin + x2label.yoffset) * (t->v_char));
! 542: if (!x2tics)
! 543: x2label_textheight += 0.5 * t->v_char;
! 544: } else
! 545: x2label_textheight = 0;
! 546:
! 547: /* tic labels */
! 548: if (x2tics & TICS_ON_BORDER) {
! 549: /* ought to consider tics on axes if axis near border */
! 550: if (vertical_x2tics) {
! 551: /* guess at tic length, since we don't know it yet
! 552: --- we'll fix it after the tic labels have been created */
! 553: x2tic_textheight = (int) (5 * (t->h_char));
! 554: } else
! 555: x2tic_textheight = (int) ((x2ticlin) * (t->v_char));
! 556: } else
! 557: x2tic_textheight = 0;
! 558:
! 559: /* tics */
! 560: if (!tic_in && ((x2tics & TICS_ON_BORDER) || ((xtics & TICS_MIRROR) && (xtics & TICS_ON_BORDER))))
! 561: x2tic_height = (int) ((t->v_tic) * ticscale);
! 562: else
! 563: x2tic_height = 0;
! 564:
! 565: /* timestamp */
! 566: if (*timelabel.text && !timelabel_bottom)
! 567: timetop_textheight = (int) ((timelin + timelabel.yoffset + 2) * (t->v_char));
! 568: else
! 569: timetop_textheight = 0;
! 570:
! 571: /* horizontal ylabel */
! 572: if (*ylabel.text && !can_rotate)
! 573: ylabel_textheight = (int) ((ylablin + ylabel.yoffset) * (t->v_char));
! 574: else
! 575: ylabel_textheight = 0;
! 576:
! 577: /* horizontal y2label */
! 578: if (*y2label.text && !can_rotate)
! 579: y2label_textheight = (int) ((y2lablin + y2label.yoffset) * (t->v_char));
! 580: else
! 581: y2label_textheight = 0;
! 582:
! 583: /* compute ytop from the various components
! 584: * unless tmargin is explicitly specified */
! 585:
! 586: ytop = (int) ((ysize + yoffset) * (t->ymax));
! 587:
! 588: if (tmargin < 0) {
! 589: int top_margin = x2label_textheight + title_textheight;
! 590: if (timetop_textheight + ylabel_textheight > top_margin)
! 591: top_margin = timetop_textheight + ylabel_textheight;
! 592: if (y2label_textheight > top_margin)
! 593: top_margin = y2label_textheight;
! 594:
! 595: top_margin += x2tic_height + x2tic_textheight;
! 596: /* FIXME: what is this additional space reservation for??? */
! 597: if (top_margin > x2tic_height)
! 598: top_margin += (int) (t->v_char);
! 599:
! 600: ytop -= top_margin;
! 601: if (ytop == (int) ((ysize + yoffset) * (t->ymax))) {
! 602: /* make room for the end of rotated ytics or y2tics */
! 603: ytop -= (int) ((t->h_char) * 2);
! 604: }
! 605: } else
! 606: ytop -= (int) ((t->v_char) * tmargin);
! 607:
! 608: /* end of preliminary ytop calculation }}} */
! 609:
! 610:
! 611: /*{{{ tentative xleft, needed for TUNDER */
! 612: if (lmargin >= 0)
! 613: xleft = (int) (xoffset * (t->xmax) + (t->h_char) * lmargin);
! 614: else
! 615: xleft = (int) (xoffset * (t->xmax) + (t->h_char) * 2);
! 616: /*}}} */
! 617:
! 618:
! 619: /*{{{ tentative xright, needed for TUNDER */
! 620: if (rmargin >= 0)
! 621: xright = (int) ((xsize + xoffset) * (t->xmax) - (t->h_char) * rmargin);
! 622: else
! 623: xright = (int) ((xsize + xoffset) * (t->xmax) - (t->h_char) * 2);
! 624: /*}}} */
! 625:
! 626:
! 627: /*{{{ preliminary ybot calculation
! 628: * first compute heights of labels and tics */
! 629:
! 630: /* tic labels */
! 631: if (xtics & TICS_ON_BORDER) {
! 632: /* ought to consider tics on axes if axis near border */
! 633: if (vertical_xtics) {
! 634: /* guess at tic length, since we don't know it yet */
! 635: xtic_textheight = (int) ((t->h_char) * 5);
! 636: } else
! 637: xtic_textheight = (int) ((t->v_char) * (xticlin + 1));
! 638: } else
! 639: xtic_textheight = 0;
! 640:
! 641: /* tics */
! 642: if (!tic_in && ((xtics & TICS_ON_BORDER) || ((x2tics & TICS_MIRROR) && (x2tics & TICS_ON_BORDER))))
! 643: xtic_height = (int) ((t->v_tic) * ticscale);
! 644: else
! 645: xtic_height = 0;
! 646:
! 647: /* xlabel */
! 648: if (xlablin) {
! 649: /* offset is subtracted because if . 0, the margin is smaller */
! 650: xlabel_textheight = (int) ((xlablin - xlabel.yoffset) * (t->v_char));
! 651: if (!xtics)
! 652: xlabel_textheight += 0.5 * t->v_char;
! 653: } else
! 654: xlabel_textheight = 0;
! 655:
! 656: /* timestamp */
! 657: if (*timelabel.text && timelabel_bottom) {
! 658: /* && !vertical_timelabel)
! 659: * DBT 11-18-98 resize plot for vertical timelabels too !
! 660: */
! 661: /* offset is subtracted because if . 0, the margin is smaller */
! 662: timebot_textheight = (int) ((timelin - timelabel.yoffset + 1.5) * (t->v_char));
! 663: }
! 664: else
! 665: timebot_textheight = 0;
! 666:
! 667: /* compute ybot from the various components
! 668: * unless bmargin is explicitly specified */
! 669:
! 670: ybot = (int) ((t->ymax) * yoffset);
! 671:
! 672: if (bmargin < 0) {
! 673: ybot += xtic_height + xtic_textheight;
! 674: if (timebot_textheight > 0 || xlabel_textheight > 0)
! 675: ybot += (timebot_textheight > xlabel_textheight) ? timebot_textheight : xlabel_textheight;
! 676: if (ybot == (t->ymax) * yoffset) {
! 677: /* make room for the end of rotated ytics or y2tics */
! 678: ybot += (int) ((t->h_char) * 2);
! 679: }
! 680: } else
! 681: ybot += (int) (bmargin * (t->v_char));
! 682:
! 683: /* end of preliminary ybot calculation }}} */
! 684:
! 685:
! 686: #define KEY_PANIC(x) if (x) { lkey = 0; goto key_escape; }
! 687:
! 688: if (lkey) {
! 689: /*{{{ essential key features */
! 690: p_width = pointsize * t->h_tic;
! 691: p_height = pointsize * t->v_tic;
! 692:
! 693: if (key_swidth >= 0)
! 694: key_sample_width = key_swidth * (t->h_char) + p_width;
! 695: else
! 696: key_sample_width = 0;
! 697:
! 698: key_entry_height = p_height * 1.25 * key_vert_factor;
! 699: if (key_entry_height < (t->v_char))
! 700: key_entry_height = (t->v_char) * key_vert_factor;
! 701:
! 702: /* count max_len key and number keys with len > 0 */
! 703: max_ptitl_len = find_maxl_keys(plots, count, &ptitl_cnt);
! 704: if ((ytlen = label_width(key_title, &ktitl_lines)) > max_ptitl_len)
! 705: max_ptitl_len = ytlen;
! 706:
! 707: if (key_reverse) {
! 708: key_sample_left = -key_sample_width;
! 709: key_sample_right = 0;
! 710: /* if key width is being used, adjust right-justified text */
! 711: key_text_left = t->h_char;
! 712: key_text_right = (t->h_char) * (max_ptitl_len + 1 + key_width_fix);
! 713: key_size_left = t->h_char - key_sample_left; /* sample left is -ve */
! 714: key_size_right = key_text_right;
! 715: } else {
! 716: key_sample_left = 0;
! 717: key_sample_right = key_sample_width;
! 718: /* if key width is being used, adjust left-justified text */
! 719: key_text_left = -(int) ((t->h_char) * (max_ptitl_len + 1 + key_width_fix));
! 720: key_text_right = -(int) (t->h_char);
! 721: key_size_left = -key_text_left;
! 722: key_size_right = key_sample_right + t->h_char;
! 723: }
! 724: key_point_offset = (key_sample_left + key_sample_right) / 2;
! 725:
! 726: /* advance width for cols */
! 727: key_col_wth = key_size_left + key_size_right;
! 728:
! 729: key_rows = ptitl_cnt;
! 730: key_cols = 1;
! 731:
! 732: /* calculate rows and cols for key - if something goes wrong,
! 733: * the tidiest way out is to set lkey = 0, and a goto
! 734: */
! 735:
! 736: if (lkey == -1) {
! 737: if (key_vpos == TUNDER) {
! 738: /* maximise no cols, limited by label-length */
! 739: key_cols = (int) (xright - xleft) / key_col_wth;
! 740: KEY_PANIC(key_cols == 0);
! 741: key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
! 742: KEY_PANIC(key_rows == 0);
! 743: /* now calculate actual no cols depending on no rows */
! 744: key_cols = (int) (ptitl_cnt + key_rows - 1) / key_rows;
! 745: KEY_PANIC(key_cols == 0);
! 746: key_col_wth = (int) (xright - xleft) / key_cols;
! 747: /* we divide into columns, then centre in column by considering
! 748: * ratio of * key_left_size to key_right_size
! 749: *
! 750: * key_size_left/(key_size_left+key_size_right) * (xright-xleft)/key_cols
! 751: * do one integer division to maximise accuracy (hope we
! 752: * don't overflow !)
! 753: */
! 754: key_xl = xleft - key_size_left + ((xright - xleft) * key_size_left) / (key_cols * (key_size_left + key_size_right));
! 755: key_xr = key_xl + key_col_wth * (key_cols - 1) + key_size_left + key_size_right;
! 756: key_yb = t->ymax * yoffset;
! 757: key_yt = key_yb + key_rows * key_entry_height + ktitl_lines * t->v_char;
! 758: ybot += key_entry_height * key_rows + (int) ((t->v_char) * (ktitl_lines + 1));
! 759: } else {
! 760: /* maximise no rows, limited by ytop-ybot */
! 761: int i = (int) (ytop - ybot - (ktitl_lines + 1) * (t->v_char)) / key_entry_height;
! 762: KEY_PANIC(i == 0);
! 763: if (ptitl_cnt > i) {
! 764: key_cols = (int) (ptitl_cnt + i - 1) / i;
! 765: /* now calculate actual no rows depending on no cols */
! 766: KEY_PANIC(key_cols == 0);
! 767: key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
! 768: }
! 769: }
! 770: /* come here if we detect a division by zero in key calculations */
! 771: key_escape:
! 772: ; /* ansi requires this */
! 773: }
! 774: /*}}} */
! 775: }
! 776: /*{{{ set up y and y2 tics */
! 777: {
! 778: /* setup_tics allows max number of tics to be specified
! 779: * but users dont like it to change with size and font,
! 780: * so we use value of 20, which is 3.5 behaviour.
! 781: * Note also that if format is '', yticlin = 0, so this gives
! 782: * division by zero.
! 783: * int guide = (ytop-ybot)/term->v_char;
! 784: */
! 785: if (ytics)
! 786: setup_tics(FIRST_Y_AXIS, &yticdef, yformat, 20 /*(int) (guide/yticlin) */ );
! 787: if (y2tics)
! 788: setup_tics(SECOND_Y_AXIS, &y2ticdef, y2format, 20 /*(int) (guide/y2ticlin) */ );
! 789: }
! 790: /*}}} */
! 791:
! 792:
! 793: /*{{{ recompute xleft based on widths of ytics, ylabel etc
! 794: unless it has been explicitly set by lmargin */
! 795:
! 796: /* tic labels */
! 797: if (ytics & TICS_ON_BORDER) {
! 798: if (vertical_ytics)
! 799: /* HBB: we will later add some white space as part of this, so
! 800: * reserve two more rows (one above, one below the text ...).
! 801: * Same will be done to similar calc.'s elsewhere */
! 802: ytic_textwidth = (int) ((t->v_char) * (yticlin + 2));
! 803: else {
! 804: widest_tic = 0; /* reset the global variable ... */
! 805: /* get gen_tics to call widest2d_callback with all labels
! 806: * the latter sets widest_tic to the length of the widest one
! 807: * ought to consider tics on axis if axis near border...
! 808: */
! 809: gen_tics(FIRST_Y_AXIS, &yticdef, 0, 0, 0.0, widest2d_callback);
! 810:
! 811: ytic_textwidth = (int) ((t->h_char) * (widest_tic + 2));
! 812: }
! 813: } else {
! 814: ytic_textwidth = 0;
! 815: }
! 816:
! 817: /* tics */
! 818: if (!tic_in && ((ytics & TICS_ON_BORDER) || ((y2tics & TICS_MIRROR) && (y2tics & TICS_ON_BORDER))))
! 819: ytic_width = (int) ((t->h_tic) * ticscale);
! 820: else
! 821: ytic_width = 0;
! 822:
! 823: /* ylabel */
! 824: if (*ylabel.text && can_rotate) {
! 825: ylabel_textwidth = (int) ((ylablin - ylabel.xoffset) * (t->v_char));
! 826: if (!ytics)
! 827: ylabel_textwidth += 0.5 * t->v_char;
! 828: }
! 829: /* this should get large for NEGATIVE ylabel.xoffsets DBT 11-5-98 */
! 830: else
! 831: ylabel_textwidth = 0;
! 832:
! 833: /* timestamp */
! 834: if (*timelabel.text && vertical_timelabel)
! 835: timelabel_textwidth = (int) ((timelin - timelabel.xoffset + 1.5) * (t->v_char));
! 836: else
! 837: timelabel_textwidth = 0;
! 838:
! 839: /* compute xleft from the various components
! 840: * unless lmargin is explicitly specified */
! 841:
! 842: xleft = (int) ((t->xmax) * xoffset);
! 843:
! 844: if (lmargin < 0) {
! 845: xleft += (timelabel_textwidth > ylabel_textwidth ? timelabel_textwidth : ylabel_textwidth)
! 846: + ytic_width + ytic_textwidth;
! 847:
! 848: if (xleft == (t->xmax) * xoffset) {
! 849: /* make room for end of xtic or x2tic label */
! 850: xleft += (int) ((t->h_char) * 2);
! 851: }
! 852: /* DBT 12-3-98 extra margin just in case */
! 853: xleft += 0.5 * t->v_char;
! 854: } else
! 855: xleft += (int) (lmargin * (t->h_char));
! 856:
! 857: /* make sure xleft is wide enough for a negatively
! 858: * x-offset horizontal timestamp
! 859: */
! 860: if (!vertical_timelabel && xleft - ytic_width - ytic_textwidth < -(int) (timelabel.xoffset * (t->h_char)))
! 861: xleft = ytic_width + ytic_textwidth - (int) (timelabel.xoffset * (t->h_char));
! 862: /* end of xleft calculation }}} */
! 863:
! 864:
! 865: /*{{{ recompute xright based on widest y2tic. y2labels, key TOUT
! 866: unless it has been explicitly set by rmargin */
! 867:
! 868: /* tic labels */
! 869: if (y2tics & TICS_ON_BORDER) {
! 870: if (vertical_y2tics)
! 871: y2tic_textwidth = (int) ((t->v_char) * (y2ticlin + 2));
! 872: else {
! 873: widest_tic = 0; /* reset the global variable ... */
! 874: /* get gen_tics to call widest2d_callback with all labels
! 875: * the latter sets widest_tic to the length of the widest one
! 876: * ought to consider tics on axis if axis near border...
! 877: */
! 878: gen_tics(SECOND_Y_AXIS, &y2ticdef, 0, 0, 0.0, widest2d_callback);
! 879:
! 880: y2tic_textwidth = (int) ((t->h_char) * (widest_tic + 2));
! 881: }
! 882: } else {
! 883: y2tic_textwidth = 0;
! 884: }
! 885:
! 886: /* tics */
! 887: if (!tic_in && ((y2tics & TICS_ON_BORDER) || ((ytics & TICS_MIRROR) && (ytics & TICS_ON_BORDER))))
! 888: y2tic_width = (int) ((t->h_tic) * ticscale);
! 889: else
! 890: y2tic_width = 0;
! 891:
! 892: /* y2label */
! 893: if (can_rotate && *y2label.text) {
! 894: y2label_textwidth = (int) ((y2lablin + y2label.xoffset) * (t->v_char));
! 895: if (!y2tics)
! 896: y2label_textwidth += 0.5 * t->v_char;
! 897: } else
! 898: y2label_textwidth = 0;
! 899:
! 900: /* compute xright from the various components
! 901: * unless rmargin is explicitly specified */
! 902:
! 903: xright = (int) ((t->xmax) * (xsize + xoffset));
! 904:
! 905: if (rmargin < 0) {
! 906: /* xright -= y2label_textwidth + y2tic_width + y2tic_textwidth; */
! 907: xright -= y2tic_width + y2tic_textwidth;
! 908: if (y2label_textwidth > 0)
! 909: xright -= y2label_textwidth;
! 910:
! 911: /* adjust for outside key */
! 912: if (lkey == -1 && key_hpos == TOUT) {
! 913: xright -= key_col_wth * key_cols;
! 914: key_xl = xright + (int) (t->h_tic);
! 915: }
! 916: if (xright == (t->xmax) * (xsize + xoffset)) {
! 917: /* make room for end of xtic or x2tic label */
! 918: xright -= (int) ((t->h_char) * 2);
! 919: }
! 920: xright -= 0.5 * t->v_char; /* DBT 12-3-98 extra margin just in case */
! 921:
! 922: } else
! 923: xright -= (int) (rmargin * (t->h_char));
! 924:
! 925: /* end of xright calculation }}} */
! 926:
! 927:
! 928: if (aspect_ratio != 0.0) {
! 929: double current_aspect_ratio;
! 930:
! 931: if (aspect_ratio < 0 && (max_array[x_axis] - min_array[x_axis]) != 0.0) {
! 932: current_aspect_ratio = -aspect_ratio * (max_array[y_axis] - min_array[y_axis]) / (max_array[x_axis] - min_array[x_axis]);
! 933: } else
! 934: current_aspect_ratio = aspect_ratio;
! 935:
! 936: /*{{{ set aspect ratio if valid and sensible */
! 937: if (current_aspect_ratio >= 0.01 && current_aspect_ratio <= 100.0) {
! 938: double current = ((double) (ytop - ybot)) / ((double) (xright - xleft));
! 939: double required = (current_aspect_ratio * (double) t->v_tic) / ((double) t->h_tic);
! 940:
! 941: if (current > required) {
! 942: /* too tall */
! 943: ytop = ybot + required * (xright - xleft);
! 944: } else {
! 945: /* HBB: y2label_x wasn't defined yet, and would be
! 946: * overwritten later */
! 947: xright = xleft + (ytop - ybot) / required;
! 948: }
! 949: }
! 950: /*}}} */
! 951: }
! 952: /*{{{ set up x and x2 tics */
! 953: /* we should base the guide on the width of the xtics, but we cannot
! 954: * use widest_tics until tics are set up. Bit of a downer - let us
! 955: * assume tics are 5 characters wide
! 956: */
! 957:
! 958: {
! 959: /* see equivalent code for ytics above
! 960: * int guide = (xright - xleft) / (5*t->h_char);
! 961: */
! 962:
! 963: if (xtics)
! 964: setup_tics(FIRST_X_AXIS, &xticdef, xformat, 20 /*guide */ );
! 965: if (x2tics)
! 966: setup_tics(SECOND_X_AXIS, &x2ticdef, x2format, 20 /*guide */ );
! 967: }
! 968: /*}}} */
! 969:
! 970:
! 971: /* adjust top and bottom margins for tic label rotation */
! 972:
! 973: if (tmargin < 0 && x2tics & TICS_ON_BORDER && vertical_x2tics) {
! 974: widest_tic = 0; /* reset the global variable ... */
! 975: gen_tics(SECOND_X_AXIS, &x2ticdef, 0, 0, 0.0, widest2d_callback);
! 976: /* HBB: redid this: remove rough guess value first. Among other reasons,
! 977: * I suspected the '-4 lines' of the original code to be in error, as the
! 978: * original calc. of x2tic_textheight uses *5* lines */
! 979: ytop += x2tic_textheight;
! 980: /* Now compute a new one and use that instead: */
! 981: x2tic_textheight = (int) ((t->h_char) * (widest_tic));
! 982: ytop -= x2tic_textheight;
! 983: }
! 984: if (bmargin < 0 && xtics & TICS_ON_BORDER && vertical_xtics) {
! 985: widest_tic = 0; /* reset the global variable ... */
! 986: gen_tics(FIRST_X_AXIS, &xticdef, 0, 0, 0.0, widest2d_callback);
! 987: /* HBB: same changes as for tmargin/ytop above */
! 988: ybot -= xtic_textheight;
! 989: xtic_textheight = (int) ((t->h_char) * widest_tic);
! 990: ybot += xtic_textheight;
! 991: }
! 992: /* compute coordinates for axis labels, title et al
! 993: * (some of these may not be used) */
! 994:
! 995: x2label_y = ytop + x2tic_height + x2tic_textheight + x2label_textheight;
! 996: if (x2tic_textheight && (title_textheight || x2label_textheight))
! 997: x2label_y += t->v_char;
! 998:
! 999: title_y = x2label_y + title_textheight;
! 1000:
! 1001: ylabel_y = ytop + x2tic_height + x2tic_textheight + ylabel_textheight;
! 1002:
! 1003: y2label_y = ytop + x2tic_height + x2tic_textheight + y2label_textheight;
! 1004:
! 1005: xlabel_y = ybot - xtic_height - xtic_textheight - xlabel_textheight + t->v_char;
! 1006: ylabel_x = xleft - ytic_width - ytic_textwidth;
! 1007: if (*ylabel.text && can_rotate)
! 1008: ylabel_x -= ylabel_textwidth;
! 1009:
! 1010: y2label_x = xright + y2tic_width + y2tic_textwidth;
! 1011: if (*y2label.text && can_rotate)
! 1012: y2label_x += y2label_textwidth - t->v_char;
! 1013:
! 1014: if (vertical_timelabel) {
! 1015: if (timelabel_bottom)
! 1016: time_y = xlabel_y - timebot_textheight + xlabel_textheight;
! 1017: else {
! 1018: time_y = title_y + timetop_textheight - title_textheight - x2label_textheight;
! 1019: }
! 1020: } else {
! 1021: if (timelabel_bottom)
! 1022: time_y = xlabel_y - timebot_textheight + xlabel_textheight;
! 1023: else if (ylabel_textheight > 0)
! 1024: time_y = ylabel_y + timetop_textheight;
! 1025: else
! 1026: time_y = ytop + x2tic_height + x2tic_textheight + timetop_textheight + (int) (t->h_char);
! 1027: }
! 1028: if (vertical_timelabel)
! 1029: time_x = xleft - ytic_width - ytic_textwidth - timelabel_textwidth;
! 1030: else
! 1031: time_x = xleft - ytic_width - ytic_textwidth + (int) (timelabel.xoffset * (t->h_char));
! 1032:
! 1033: xtic_y = ybot - xtic_height - (vertical_xtics ? (int) (t->h_char) : (int) (t->v_char));
! 1034:
! 1035: x2tic_y = ytop + x2tic_height + (vertical_x2tics ? (int) (t->h_char) : x2tic_textheight);
! 1036:
! 1037: ytic_x = xleft - ytic_width - (vertical_ytics ? (ytic_textwidth - (int) t->v_char) : (int) (t->h_char));
! 1038:
! 1039: y2tic_x = xright + y2tic_width + (vertical_y2tics ? (int) (t->v_char) : (int) (t->h_char));
! 1040:
! 1041: /* restore text to horizontal [we tested rotation above] */
! 1042: (void) (*t->text_angle) (0);
! 1043:
! 1044: /* needed for map_position() below */
! 1045:
! 1046: scale[FIRST_Y_AXIS] = (ytop - ybot) / (max_array[FIRST_Y_AXIS] - min_array[FIRST_Y_AXIS]);
! 1047: scale[FIRST_X_AXIS] = (xright - xleft) / (max_array[FIRST_X_AXIS] - min_array[FIRST_X_AXIS]);
! 1048: scale[SECOND_Y_AXIS] = (ytop - ybot) / (max_array[SECOND_Y_AXIS] - min_array[SECOND_Y_AXIS]);
! 1049: scale[SECOND_X_AXIS] = (xright - xleft) / (max_array[SECOND_X_AXIS] - min_array[SECOND_X_AXIS]);
! 1050:
! 1051: /*{{{ calculate the window in the grid for the key */
! 1052: if (lkey == 1 || (lkey == -1 && key_vpos != TUNDER)) {
! 1053: /* calculate space for keys to prevent grid overwrite the keys */
! 1054: /* do it even if there is no grid, as do_plot will use these to position key */
! 1055: key_w = key_col_wth * key_cols;
! 1056: key_h = (ktitl_lines) * t->v_char + key_rows * key_entry_height;
! 1057: if (lkey == -1) {
! 1058: if (key_vpos == TTOP) {
! 1059: key_yt = (int) ytop - (t->v_tic);
! 1060: key_yb = key_yt - key_h;
! 1061: } else {
! 1062: key_yb = ybot + (t->v_tic);
! 1063: key_yt = key_yb + key_h;
! 1064: }
! 1065: if (key_hpos == TLEFT) {
! 1066: key_xl = xleft + (t->h_char); /* for Left just */
! 1067: key_xr = key_xl + key_w;
! 1068: } else if (key_hpos == TRIGHT) {
! 1069: key_xr = xright - (t->h_char); /* for Right just */
! 1070: key_xl = key_xr - key_w;
! 1071: } else { /* TOUT */
! 1072: /* do this here for do_plot() */
! 1073: /* align right first since rmargin may be manual */
! 1074: key_xr = (xsize + xoffset) * (t->xmax) - (t->h_char);
! 1075: key_xl = key_xr - key_w;
! 1076: }
! 1077: } else {
! 1078: unsigned int x, y;
! 1079: map_position(&key_user_pos, &x, &y, "key");
! 1080: key_xl = x - key_size_left;
! 1081: key_xr = key_xl + key_w;
! 1082: key_yt = y + (ktitl_lines ? t->v_char : key_entry_height) / 2;
! 1083: key_yb = key_yt - key_h;
! 1084: }
! 1085: }
! 1086: /*}}} */
! 1087:
! 1088: }
! 1089:
! 1090: /*}}} */
! 1091:
! 1092: /*{{{ dbl_raise() */
! 1093: static double dbl_raise(x, y)
! 1094: double x;
! 1095: int y;
! 1096: {
! 1097: register int i = abs(y);
! 1098: double val = 1.0;
! 1099:
! 1100: while (--i >= 0)
! 1101: val *= x;
! 1102:
! 1103: if (y < 0)
! 1104: return (1.0 / val);
! 1105: return (val);
! 1106: }
! 1107: /*}}} */
! 1108:
! 1109: /*{{{ timetic_fmt() */
! 1110: void timetic_format(axis, amin, amax)
! 1111: int axis;
! 1112: double amin, amax;
! 1113: {
! 1114: struct tm tmin, tmax;
! 1115:
! 1116: *ticfmt[axis] = 0; /* make sure we strcat to empty string */
! 1117:
! 1118: ggmtime(&tmin, (double) time_tic_just(timelevel[axis], amin));
! 1119: ggmtime(&tmax, (double) time_tic_just(timelevel[axis], amax));
! 1120: /*
! 1121: if ( tmax.tm_year == tmin.tm_year &&
! 1122: tmax.tm_mon == tmin.tm_mon &&
! 1123: tmax.tm_mday == tmin.tm_mday ) {
! 1124: */
! 1125: if (tmax.tm_year == tmin.tm_year &&
! 1126: tmax.tm_yday == tmin.tm_yday) {
! 1127: /* same day, skip date */
! 1128: if (tmax.tm_hour != tmin.tm_hour) {
! 1129: strcpy(ticfmt[axis], "%H");
! 1130: }
! 1131: if (timelevel[axis] < 3) {
! 1132: if (strlen(ticfmt[axis]))
! 1133: strcat(ticfmt[axis], ":");
! 1134: strcat(ticfmt[axis], "%M");
! 1135: }
! 1136: if (timelevel[axis] < 2) {
! 1137: strcat(ticfmt[axis], ":%S");
! 1138: }
! 1139: } else {
! 1140: if (tmax.tm_year != tmin.tm_year) {
! 1141: /* different years, include year in ticlabel */
! 1142: /* check convention, day/month or month/day */
! 1143: if (strchr(timefmt, 'm') < strchr(timefmt, 'd')) {
! 1144: strcpy(ticfmt[axis], "%m/%d/%");
! 1145: } else {
! 1146: strcpy(ticfmt[axis], "%d/%m/%");
! 1147: }
! 1148: if (((int) (tmax.tm_year / 100)) != ((int) (tmin.tm_year / 100))) {
! 1149: strcat(ticfmt[axis], "Y");
! 1150: } else {
! 1151: strcat(ticfmt[axis], "y");
! 1152: }
! 1153:
! 1154: } else {
! 1155: if (strchr(timefmt, 'm') < strchr(timefmt, 'd')) {
! 1156: strcpy(ticfmt[axis], "%m/%d");
! 1157: } else {
! 1158: strcpy(ticfmt[axis], "%d/%m");
! 1159: }
! 1160: }
! 1161: if (timelevel[axis] < 4) {
! 1162: strcat(ticfmt[axis], "\n%H:%M");
! 1163: }
! 1164: }
! 1165: }
! 1166: /*}}} */
! 1167:
! 1168: /*{{{ set_tic() */
! 1169: /* the guide parameter was intended to allow the number of tics
! 1170: * to depend on the relative sizes of the plot and the font.
! 1171: * It is the approximate upper limit on number of tics allowed.
! 1172: * But it did not go down well with the users.
! 1173: * A value of 20 gives the same behaviour as 3.5, so that is
! 1174: * hardwired into the calls to here. Maybe we will restore it
! 1175: * to the automatic calculation one day
! 1176: */
! 1177:
! 1178: double set_tic(l10, guide)
! 1179: double l10;
! 1180: int guide;
! 1181: {
! 1182: double xnorm, tics, posns;
! 1183:
! 1184: int fl = (int) floor(l10);
! 1185: xnorm = pow(10.0, l10 - fl); /* approx number of decades */
! 1186:
! 1187: posns = guide / xnorm; /* approx number of tic posns per decade */
! 1188:
! 1189: if (posns > 40)
! 1190: tics = 0.05; /* eg 0, .05, .10, ... */
! 1191: else if (posns > 20)
! 1192: tics = 0.1; /* eg 0, .1, .2, ... */
! 1193: else if (posns > 10)
! 1194: tics = 0.2; /* eg 0,0.2,0.4,... */
! 1195: else if (posns > 4)
! 1196: tics = 0.5; /* 0,0.5,1, */
! 1197: else if (posns > 1)
! 1198: tics = 1; /* 0,1,2,.... */
! 1199: else if (posns > 0.5)
! 1200: tics = 2; /* 0, 2, 4, 6 */
! 1201: else
! 1202: /* getting desperate... the ceil is to make sure we
! 1203: * go over rather than under - eg plot [-10:10] x*x
! 1204: * gives a range of about 99.999 - tics=xnorm gives
! 1205: * tics at 0, 99.99 and 109.98 - BAD !
! 1206: * This way, inaccuracy the other way will round
! 1207: * up (eg 0->100.0001 => tics at 0 and 101
! 1208: * I think latter is better than former
! 1209: */
! 1210: tics = ceil(xnorm);
! 1211:
! 1212: return (tics * dbl_raise(10.0, fl));
! 1213: }
! 1214: /*}}} */
! 1215:
! 1216: /*{{{ make_tics() */
! 1217: static double make_tics(axis, guide)
! 1218: int axis, guide;
! 1219: {
! 1220: register double xr, tic, l10;
! 1221:
! 1222: xr = fabs(min_array[axis] - max_array[axis]);
! 1223:
! 1224: l10 = log10(xr);
! 1225: tic = set_tic(l10, guide);
! 1226: if (log_array[axis] && tic < 1.0)
! 1227: tic = 1.0;
! 1228: if (datatype[axis] == TIME) {
! 1229: struct tm ftm, etm;
! 1230: /* this is not fun */
! 1231: ggmtime(&ftm, (double) min_array[axis]);
! 1232: ggmtime(&etm, (double) max_array[axis]);
! 1233:
! 1234: timelevel[axis] = 0; /* seconds */
! 1235: if (tic > 20) {
! 1236: /* turn tic into units of minutes */
! 1237: tic = set_tic(log10(xr / 60.0), guide) * 60;
! 1238: timelevel[axis] = 1; /* minutes */
! 1239: }
! 1240: if (tic > 20 * 60) {
! 1241: /* turn tic into units of hours */
! 1242: tic = set_tic(log10(xr / 3600.0), guide) * 3600;
! 1243: timelevel[axis] = 2; /* hours */
! 1244: }
! 1245: if (tic > 2 * 3600) {
! 1246: /* need some tickling */
! 1247: tic = set_tic(log10(xr / (3 * 3600.0)), guide) * 3 * 3600;
! 1248: }
! 1249: if (tic > 6 * 3600) {
! 1250: /* turn tic into units of days */
! 1251: tic = set_tic(log10(xr / DAY_SEC), guide) * DAY_SEC;
! 1252: timelevel[axis] = 3; /* days */
! 1253: }
! 1254: if (tic > 3 * DAY_SEC) {
! 1255: /* turn tic into units of weeks */
! 1256: tic = set_tic(log10(xr / WEEK_SEC), guide) * WEEK_SEC;
! 1257: if (tic < WEEK_SEC) { /* force */
! 1258: tic = WEEK_SEC;
! 1259: }
! 1260: timelevel[axis] = 4; /* weeks */
! 1261: }
! 1262: if (tic > 3 * WEEK_SEC) {
! 1263: /* turn tic into units of month */
! 1264: tic = set_tic(log10(xr / MON_SEC), guide) * MON_SEC;
! 1265: if (tic < MON_SEC) { /* force */
! 1266: tic = MON_SEC;
! 1267: }
! 1268: timelevel[axis] = 5; /* month */
! 1269: }
! 1270: if (tic > 2 * MON_SEC) {
! 1271: /* turn tic into units of month */
! 1272: tic = set_tic(log10(xr / (3 * MON_SEC)), guide) * 3 * MON_SEC;
! 1273: }
! 1274: if (tic > 6 * MON_SEC) {
! 1275: /* turn tic into units of years */
! 1276: tic = set_tic(log10(xr / YEAR_SEC), guide) * YEAR_SEC;
! 1277: if (tic < (YEAR_SEC / 2)) {
! 1278: tic = YEAR_SEC / 2;
! 1279: }
! 1280: timelevel[axis] = 6; /* year */
! 1281: }
! 1282: }
! 1283: return (tic);
! 1284: }
! 1285: /*}}} */
! 1286:
! 1287:
! 1288: void do_plot(plots, pcount)
! 1289: struct curve_points *plots;
! 1290: int pcount; /* count of plots in linked list */
! 1291: {
! 1292:
! 1293: /* BODGES BEFORE I FIX IT UP */
! 1294: #define ytic ticstep[y_axis]
! 1295: #define xtic ticstep[x_axis]
! 1296:
! 1297: register struct termentry *t = term;
! 1298: register int curve;
! 1299: int axis_zero[AXIS_ARRAY_SIZE]; /* axes in terminal coords for FIRST_X_AXIS, etc */
! 1300: register struct curve_points *this_plot = NULL;
! 1301: register int xl = 0, yl = 0; /* avoid gcc -Wall warning */
! 1302: register int key_count = 0;
! 1303: /* only a Pyramid would have this many registers! */
! 1304: struct text_label *this_label;
! 1305: struct arrow_def *this_arrow;
! 1306: TBOOLEAN scaling;
! 1307: char ss[MAX_LINE_LEN + 1], *s, *e;
! 1308:
! 1309: /* so that macros for x_min etc pick up correct values
! 1310: * until this is done properly
! 1311: */
! 1312:
! 1313: x_axis = FIRST_X_AXIS;
! 1314: y_axis = FIRST_Y_AXIS;
! 1315:
! 1316: /* Apply the desired viewport offsets. */
! 1317: if (y_min < y_max) {
! 1318: y_min -= boff;
! 1319: y_max += toff;
! 1320: } else {
! 1321: y_max -= boff;
! 1322: y_min += toff;
! 1323: }
! 1324: if (x_min < x_max) {
! 1325: x_min -= loff;
! 1326: x_max += roff;
! 1327: } else {
! 1328: x_max -= loff;
! 1329: x_min += roff;
! 1330: }
! 1331:
! 1332: /*
! 1333: * In the beginning, this "empty range" test was for exact
! 1334: * equality, eg y_min == y_max , but that caused an infinite
! 1335: * loop once. Then the test was changed to check for being
! 1336: * within the 'zero' threshold, fabs(y_max - y_min) < zero) ,
! 1337: * but that prevented plotting data with ranges below 'zero'.
! 1338: * Now it's an absolute equality test again, since fixup_range()
! 1339: * should have widened empty ranges before we get here.
! 1340: */
! 1341: if (x_min == x_max)
! 1342: int_error("x_min should not equal x_max!", NO_CARET);
! 1343: if (y_min == y_max)
! 1344: int_error("y_min should not equal y_max!", NO_CARET);
! 1345:
! 1346: term_init(); /* may set xmax/ymax */
! 1347:
! 1348: /* compute boundary for plot (xleft, xright, ytop, ybot)
! 1349: * also calculates tics, since xtics depend on xleft
! 1350: * but xleft depends on ytics. Boundary calculations
! 1351: * depend on term->v_char etc, so terminal must be
! 1352: * initialised.
! 1353: */
! 1354:
! 1355: scaling = (*t->scale) (xsize, ysize);
! 1356:
! 1357: boundary(scaling, plots, pcount);
! 1358:
! 1359: screen_ok = FALSE;
! 1360:
! 1361: term_start_plot();
! 1362:
! 1363: /* DRAW TICS AND GRID */
! 1364: term_apply_lp_properties(&border_lp); /* border linetype */
! 1365: largest_polar_circle = 0;
! 1366:
! 1367: /* select first mapping */
! 1368: x_axis = FIRST_X_AXIS;
! 1369: y_axis = FIRST_Y_AXIS;
! 1370:
! 1371: /* label first y axis tics */
! 1372: if (ytics) {
! 1373: int axis = map_x(ZERO);
! 1374: /* set the globals ytick2d_callback() needs */
! 1375:
! 1376: if (rotate_ytics && (*t->text_angle) (1)) {
! 1377: tic_hjust = CENTRE;
! 1378: tic_vjust = JUST_BOT;
! 1379: rotate_tics = 1; /* HBB 980629 */
! 1380: ytic_x += t->v_char / 2;
! 1381: } else {
! 1382: tic_hjust = RIGHT;
! 1383: tic_vjust = JUST_CENTRE;
! 1384: rotate_tics = 0; /* HBB 980629 */
! 1385: }
! 1386:
! 1387: if (ytics & TICS_MIRROR)
! 1388: tic_mirror = xright;
! 1389: else
! 1390: tic_mirror = -1; /* no thank you */
! 1391:
! 1392: if ((ytics & TICS_ON_AXIS) && !log_array[FIRST_X_AXIS] && inrange(axis, xleft, xright)) {
! 1393: tic_start = axis;
! 1394: tic_direction = -1;
! 1395: if (ytics & TICS_MIRROR)
! 1396: tic_mirror = tic_start;
! 1397: /* put text at boundary if axis is close to boundary */
! 1398: tic_text = (((tic_start - xleft) > (3 * t->h_char)) ? tic_start : xleft) - t->h_char;
! 1399: } else {
! 1400: tic_start = xleft;
! 1401: tic_direction = tic_in ? 1 : -1;
! 1402: tic_text = ytic_x;
! 1403: }
! 1404: /* go for it */
! 1405: gen_tics(FIRST_Y_AXIS, &yticdef,
! 1406: work_grid.l_type & (GRID_Y | GRID_MY),
! 1407: mytics, mytfreq, ytick2d_callback);
! 1408: (*t->text_angle) (0); /* reset rotation angle */
! 1409:
! 1410: }
! 1411: /* label first x axis tics */
! 1412: if (xtics) {
! 1413: int axis = map_y(ZERO);
! 1414: /* set the globals xtick2d_callback() needs */
! 1415:
! 1416: if (rotate_xtics && (*t->text_angle) (1)) {
! 1417: tic_hjust = RIGHT;
! 1418: tic_vjust = JUST_CENTRE;
! 1419: rotate_tics = 1; /* HBB 980629 */
! 1420: } else {
! 1421: tic_hjust = CENTRE;
! 1422: tic_vjust = JUST_TOP;
! 1423: rotate_tics = 0; /* HBB 980629 */
! 1424: }
! 1425:
! 1426: if (xtics & TICS_MIRROR)
! 1427: tic_mirror = ytop;
! 1428: else
! 1429: tic_mirror = -1; /* no thank you */
! 1430: if ((xtics & TICS_ON_AXIS) && !log_array[FIRST_Y_AXIS] && inrange(axis, ybot, ytop)) {
! 1431: tic_start = axis;
! 1432: tic_direction = -1;
! 1433: if (xtics & TICS_MIRROR)
! 1434: tic_mirror = tic_start;
! 1435: /* put text at boundary if axis is close to boundary */
! 1436: if (tic_start - ybot > 2 * t->v_char)
! 1437: tic_text = tic_start - ticscale * t->v_tic - t->v_char;
! 1438: else
! 1439: tic_text = ybot - t->v_char;
! 1440: } else {
! 1441: tic_start = ybot;
! 1442: tic_direction = tic_in ? 1 : -1;
! 1443: tic_text = xtic_y;
! 1444: }
! 1445: /* go for it */
! 1446: gen_tics(FIRST_X_AXIS, &xticdef,
! 1447: work_grid.l_type & (GRID_X | GRID_MX),
! 1448: mxtics, mxtfreq, xtick2d_callback);
! 1449: (*t->text_angle) (0); /* reset rotation angle */
! 1450: }
! 1451: /* select second mapping */
! 1452: x_axis = SECOND_X_AXIS;
! 1453: y_axis = SECOND_Y_AXIS;
! 1454:
! 1455: /* label second y axis tics */
! 1456: if (y2tics) {
! 1457: /* set the globalss ytick2d_callback() needs */
! 1458: int axis = map_x(ZERO);
! 1459:
! 1460: if (rotate_y2tics && (*t->text_angle) (1)) {
! 1461: tic_hjust = CENTRE;
! 1462: tic_vjust = JUST_TOP;
! 1463: rotate_tics = 1; /* HBB 980629 */
! 1464: } else {
! 1465: tic_hjust = LEFT;
! 1466: tic_vjust = JUST_CENTRE;
! 1467: rotate_tics = 0; /* HBB 980629 */
! 1468: }
! 1469:
! 1470: if (y2tics & TICS_MIRROR)
! 1471: tic_mirror = xleft;
! 1472: else
! 1473: tic_mirror = -1; /* no thank you */
! 1474: if ((y2tics & TICS_ON_AXIS) && !log_array[FIRST_X_AXIS] && inrange(axis, xleft, xright)) {
! 1475: tic_start = axis;
! 1476: tic_direction = 1;
! 1477: if (y2tics & TICS_MIRROR)
! 1478: tic_mirror = tic_start;
! 1479: /* put text at boundary if axis is close to boundary */
! 1480: tic_text = (((xright - tic_start) > (3 * t->h_char)) ? tic_start : xright) + t->h_char;
! 1481: } else {
! 1482: tic_start = xright;
! 1483: tic_direction = tic_in ? -1 : 1;
! 1484: tic_text = y2tic_x;
! 1485: }
! 1486: /* go for it */
! 1487: gen_tics(SECOND_Y_AXIS, &y2ticdef,
! 1488: work_grid.l_type & (GRID_Y2 | GRID_MY2),
! 1489: my2tics, my2tfreq, ytick2d_callback);
! 1490: (*t->text_angle) (0); /* reset rotation angle */
! 1491: }
! 1492: /* label second x axis tics */
! 1493: if (x2tics) {
! 1494: int axis = map_y(ZERO);
! 1495: /* set the globals xtick2d_callback() needs */
! 1496:
! 1497: if (rotate_x2tics && (*t->text_angle) (1)) {
! 1498: tic_hjust = LEFT;
! 1499: tic_vjust = JUST_CENTRE;
! 1500: rotate_tics = 1; /* HBB 980629 */
! 1501: } else {
! 1502: tic_hjust = CENTRE;
! 1503: tic_vjust = JUST_BOT;
! 1504: rotate_tics = 0; /* HBB 980629 */
! 1505: }
! 1506:
! 1507: if (x2tics & TICS_MIRROR)
! 1508: tic_mirror = ybot;
! 1509: else
! 1510: tic_mirror = -1; /* no thank you */
! 1511: if ((x2tics & TICS_ON_AXIS) && !log_array[SECOND_Y_AXIS] && inrange(axis, ybot, ytop)) {
! 1512: tic_start = axis;
! 1513: tic_direction = 1;
! 1514: if (x2tics & TICS_MIRROR)
! 1515: tic_mirror = tic_start;
! 1516: /* put text at boundary if axis is close to boundary */
! 1517: tic_text = (((ytop - tic_start) > (2 * t->v_char)) ? tic_start : ytop) + t->v_char;
! 1518: } else {
! 1519: tic_start = ytop;
! 1520: tic_direction = tic_in ? -1 : 1;
! 1521: tic_text = x2tic_y;
! 1522: }
! 1523: /* go for it */
! 1524: gen_tics(SECOND_X_AXIS, &x2ticdef,
! 1525: work_grid.l_type & (GRID_X2 | GRID_MX2),
! 1526: mx2tics, mx2tfreq, xtick2d_callback);
! 1527: (*t->text_angle) (0); /* reset rotation angle */
! 1528: }
! 1529: /* select first mapping */
! 1530: x_axis = FIRST_X_AXIS;
! 1531: y_axis = FIRST_Y_AXIS;
! 1532:
! 1533: /* RADIAL LINES FOR POLAR GRID */
! 1534:
! 1535: /* note that draw_clip_line takes unsigneds, but (fortunately)
! 1536: * clip_line takes signeds
! 1537: */
! 1538: if (polar_grid_angle) {
! 1539: double theta = 0;
! 1540: int ox = map_x(0);
! 1541: int oy = map_y(0);
! 1542: term_apply_lp_properties(&grid_lp);
! 1543: for (theta = 0; theta < 6.29; theta += polar_grid_angle) {
! 1544: /* copy ox in case it gets moved (but it shouldn't) */
! 1545: int oox = ox;
! 1546: int ooy = oy;
! 1547: int x = map_x(largest_polar_circle * cos(theta));
! 1548: int y = map_y(largest_polar_circle * sin(theta));
! 1549: if (clip_line(&oox, &ooy, &x, &y)) {
! 1550: (*t->move) ((unsigned int) oox, (unsigned int) ooy);
! 1551: (*t->vector) ((unsigned int) x, (unsigned int) y);
! 1552: }
! 1553: }
! 1554: draw_clip_line(ox, oy,
! 1555: map_x(largest_polar_circle * cos(theta)),
! 1556: map_y(largest_polar_circle * sin(theta)));
! 1557: }
! 1558: /* DRAW AXES */
! 1559:
! 1560: /* after grid so that axes linetypes are on top */
! 1561:
! 1562: x_axis = FIRST_X_AXIS;
! 1563: y_axis = FIRST_Y_AXIS; /* chose scaling */
! 1564: axis_zero[FIRST_X_AXIS] = map_y(0.0);
! 1565: axis_zero[FIRST_Y_AXIS] = map_x(0.0);
! 1566:
! 1567: if (axis_zero[FIRST_X_AXIS] < ybot || is_log_y)
! 1568: axis_zero[FIRST_X_AXIS] = ybot; /* save for impulse plotting */
! 1569: else if (axis_zero[FIRST_X_AXIS] >= ytop)
! 1570: axis_zero[FIRST_X_AXIS] = ytop;
! 1571: else if (xzeroaxis.l_type > -3) {
! 1572: term_apply_lp_properties(&xzeroaxis);
! 1573: (*t->move) (xleft, axis_zero[FIRST_X_AXIS]);
! 1574: (*t->vector) (xright, axis_zero[FIRST_X_AXIS]);
! 1575: }
! 1576: if ((yzeroaxis.l_type > -3) && !is_log_x
! 1577: && axis_zero[FIRST_Y_AXIS] >= xleft
! 1578: && axis_zero[FIRST_Y_AXIS] < xright) {
! 1579: term_apply_lp_properties(&yzeroaxis);
! 1580: (*t->move) (axis_zero[FIRST_Y_AXIS], ybot);
! 1581: (*t->vector) (axis_zero[FIRST_Y_AXIS], ytop);
! 1582: }
! 1583: x_axis = SECOND_X_AXIS;
! 1584: y_axis = SECOND_Y_AXIS; /* chose scaling */
! 1585: axis_zero[SECOND_X_AXIS] = map_y(0.0);
! 1586: axis_zero[SECOND_Y_AXIS] = map_x(0.0);
! 1587:
! 1588: if (axis_zero[SECOND_X_AXIS] < ybot || is_log_y2)
! 1589: axis_zero[SECOND_X_AXIS] = ybot; /* save for impulse plotting */
! 1590: else if (axis_zero[SECOND_X_AXIS] >= ytop)
! 1591: axis_zero[SECOND_X_AXIS] = ytop;
! 1592: else if (x2zeroaxis.l_type > -3) {
! 1593: term_apply_lp_properties(&x2zeroaxis);
! 1594: (*t->move) (xleft, axis_zero[SECOND_X_AXIS]);
! 1595: (*t->vector) (xright, axis_zero[SECOND_X_AXIS]);
! 1596: }
! 1597: if ((y2zeroaxis.l_type > -3) && !is_log_x2 && axis_zero[SECOND_Y_AXIS] >= xleft &&
! 1598: axis_zero[SECOND_Y_AXIS] < xright) {
! 1599: term_apply_lp_properties(&y2zeroaxis);
! 1600: (*t->move) (axis_zero[SECOND_Y_AXIS], ybot);
! 1601: (*t->vector) (axis_zero[SECOND_Y_AXIS], ytop);
! 1602: }
! 1603: /* DRAW PLOT BORDER */
! 1604: if (draw_border) {
! 1605: /* HBB 980609: just in case: move over to border linestyle only
! 1606: * if border is to be drawn */
! 1607: term_apply_lp_properties(&border_lp); /* border linetype */
! 1608: (*t->move) (xleft, ybot);
! 1609: if (border_south) {
! 1610: (*t->vector) (xright, ybot);
! 1611: } else {
! 1612: (*t->move) (xright, ybot);
! 1613: }
! 1614: if (border_east) {
! 1615: (*t->vector) (xright, ytop);
! 1616: } else {
! 1617: (*t->move) (xright, ytop);
! 1618: }
! 1619: if (border_north) {
! 1620: (*t->vector) (xleft, ytop);
! 1621: } else {
! 1622: (*t->move) (xleft, ytop);
! 1623: }
! 1624: if (border_west) {
! 1625: (*t->vector) (xleft, ybot);
! 1626: } else {
! 1627: (*t->move) (xleft, ybot);
! 1628: }
! 1629: }
! 1630: /* YLABEL */
! 1631: if (*ylabel.text) {
! 1632: strcpy(ss, ylabel.text);
! 1633: /* we worked out x-posn in boundary() */
! 1634: if ((*t->text_angle) (1)) {
! 1635: unsigned int x = ylabel_x + (t->v_char / 2);
! 1636: unsigned int y = (ytop + ybot) / 2 + ylabel.yoffset * (t->h_char);
! 1637: write_multiline(x, y, ss, CENTRE, JUST_TOP, 1, ylabel.font);
! 1638: (*t->text_angle) (0);
! 1639: } else {
! 1640: /* really bottom just, but we know number of lines
! 1641: so we need to adjust x-posn by one line */
! 1642: unsigned int x = ylabel_x;
! 1643: unsigned int y = ylabel_y;
! 1644: write_multiline(x, y, ss, LEFT, JUST_TOP, 0, ylabel.font);
! 1645: }
! 1646: }
! 1647: /* Y2LABEL */
! 1648: if (*y2label.text) {
! 1649: strcpy(ss, y2label.text);
! 1650: /* we worked out coordinates in boundary() */
! 1651: if ((*t->text_angle) (1)) {
! 1652: unsigned int x = y2label_x + (t->v_char / 2) - 1;
! 1653: unsigned int y = (ytop + ybot) / 2 + y2label.yoffset * (t->h_char);
! 1654: write_multiline(x, y, ss, CENTRE, JUST_TOP, 1, y2label.font);
! 1655: (*t->text_angle) (0);
! 1656: } else {
! 1657: /* really bottom just, but we know number of lines */
! 1658: unsigned int x = y2label_x;
! 1659: unsigned int y = y2label_y;
! 1660: write_multiline(x, y, ss, RIGHT, JUST_TOP, 0, y2label.font);
! 1661: }
! 1662: }
! 1663: /* XLABEL */
! 1664: if (*xlabel.text) {
! 1665: unsigned int x = (xright + xleft) / 2 + xlabel.xoffset * (t->h_char);
! 1666: unsigned int y = xlabel_y - t->v_char / 2; /* HBB */
! 1667: strcpy(ss, xlabel.text);
! 1668: write_multiline(x, y, ss, CENTRE, JUST_TOP, 0, xlabel.font);
! 1669: }
! 1670: /* PLACE TITLE */
! 1671: if (*title.text) {
! 1672: /* we worked out y-coordinate in boundary() */
! 1673: unsigned int x = (xleft + xright) / 2 + title.xoffset * t->h_char;
! 1674: unsigned int y = title_y - t->v_char / 2;
! 1675: strcpy(ss, title.text);
! 1676: write_multiline(x, y, ss, CENTRE, JUST_TOP, 0, title.font);
! 1677: }
! 1678: /* X2LABEL */
! 1679: if (*x2label.text) {
! 1680: /* we worked out y-coordinate in boundary() */
! 1681: unsigned int x = (xright + xleft) / 2 + x2label.xoffset * (t->h_char);
! 1682: unsigned int y = x2label_y - t->v_char / 2 - 1;
! 1683: strcpy(ss, x2label.text);
! 1684: write_multiline(x, y, ss, CENTRE, JUST_TOP, 0, x2label.font);
! 1685: }
! 1686: /* PLACE TIMEDATE */
! 1687: if (*timelabel.text) {
! 1688: /* we worked out coordinates in boundary() */
! 1689: char str[MAX_LINE_LEN + 1];
! 1690: time_t now;
! 1691: unsigned int x = time_x;
! 1692: unsigned int y = time_y;
! 1693: time(&now);
! 1694: strftime(str, MAX_LINE_LEN, timelabel.text, localtime(&now));
! 1695:
! 1696: if (timelabel_rotate && (*t->text_angle) (1)) {
! 1697: x += t->v_char / 2; /* HBB */
! 1698: if (timelabel_bottom)
! 1699: write_multiline(x, y, str, LEFT, JUST_TOP, 1, timelabel.font);
! 1700: else
! 1701: write_multiline(x, y, str, RIGHT, JUST_TOP, 1, timelabel.font);
! 1702: (*t->text_angle) (0);
! 1703: } else {
! 1704: y -= t->v_char / 2; /* HBB */
! 1705: if (timelabel_bottom)
! 1706: write_multiline(x, y, str, LEFT, JUST_BOT, 0, timelabel.font);
! 1707: else
! 1708: write_multiline(x, y, str, LEFT, JUST_TOP, 0, timelabel.font);
! 1709: }
! 1710: }
! 1711: /* PLACE LABELS */
! 1712: for (this_label = first_label; this_label != NULL;
! 1713: this_label = this_label->next) {
! 1714: unsigned int x, y;
! 1715: map_position(&this_label->place, &x, &y, "label");
! 1716: strcpy(ss, this_label->text);
! 1717: if (this_label->rotate && (*t->text_angle) (1)) {
! 1718: write_multiline(x, y, ss, this_label->pos, JUST_TOP, 1, this_label->font);
! 1719: (*t->text_angle) (0);
! 1720: } else {
! 1721: write_multiline(x, y, ss, this_label->pos, JUST_TOP, 0, this_label->font);
! 1722: }
! 1723: }
! 1724:
! 1725: /* PLACE ARROWS */
! 1726: for (this_arrow = first_arrow; this_arrow != NULL;
! 1727: this_arrow = this_arrow->next) {
! 1728: unsigned int sx, sy, ex, ey;
! 1729: map_position(&this_arrow->start, &sx, &sy, "arrow");
! 1730: map_position(&this_arrow->end, &ex, &ey, "arrow");
! 1731:
! 1732: term_apply_lp_properties(&(this_arrow->lp_properties));
! 1733: (*t->arrow) (sx, sy, ex, ey, this_arrow->head);
! 1734: }
! 1735:
! 1736: /* WORK OUT KEY SETTINGS AND DO KEY TITLE / BOX */
! 1737:
! 1738:
! 1739: if (lkey) { /* may have been cancelled if something went wrong */
! 1740: /* just use key_xl etc worked out in boundary() */
! 1741: xl = key_xl + key_size_left;
! 1742: yl = key_yt;
! 1743:
! 1744: if (*key_title) {
! 1745: sprintf(ss, "%s\n", key_title);
! 1746: s = ss;
! 1747: yl -= t->v_char / 2;
! 1748: while ((e = (char *) strchr(s, '\n')) != NULL) {
! 1749: *e = '\0';
! 1750: if (key_just == JLEFT) {
! 1751: (*t->justify_text) (LEFT);
! 1752: (*t->put_text) (xl + key_text_left, yl, s);
! 1753: } else {
! 1754: if ((*t->justify_text) (RIGHT)) {
! 1755: (*t->put_text) (xl + key_text_right, yl, s);
! 1756: } else {
! 1757: int x = xl + key_text_right - (t->h_char) * strlen(s);
! 1758: if (key_hpos == TOUT || inrange(x, xleft, xright))
! 1759: (*t->put_text) (x, yl, s);
! 1760: }
! 1761: }
! 1762: s = ++e;
! 1763: yl -= t->v_char;
! 1764: }
! 1765: yl += t->v_char / 2;
! 1766: }
! 1767: yl_ref = yl -= key_entry_height / 2; /* centralise the keys */
! 1768: key_count = 0;
! 1769:
! 1770: if (key_box.l_type > -3) {
! 1771: term_apply_lp_properties(&key_box);
! 1772: (*t->move) (key_xl, key_yb);
! 1773: (*t->vector) (key_xl, key_yt);
! 1774: (*t->vector) (key_xr, key_yt);
! 1775: (*t->vector) (key_xr, key_yb);
! 1776: (*t->vector) (key_xl, key_yb);
! 1777: /* draw a horizontal line between key title
! 1778: and first entry *//* JFi */
! 1779: (*t->move) (key_xl, key_yt - (ktitl_lines) * t->v_char); /* JFi */
! 1780: (*t->vector) (key_xr, key_yt - (ktitl_lines) * t->v_char); /* JFi */
! 1781: }
! 1782: } /* lkey */
! 1783: /* DRAW CURVES */
! 1784: this_plot = plots;
! 1785: for (curve = 0; curve < pcount; this_plot = this_plot->next_cp, curve++) {
! 1786: int localkey = lkey; /* a local copy */
! 1787:
! 1788: /* set scaling for this plot's axes */
! 1789: x_axis = this_plot->x_axis;
! 1790: y_axis = this_plot->y_axis;
! 1791:
! 1792: term_apply_lp_properties(&(this_plot->lp_properties));
! 1793:
! 1794: if (this_plot->title && !*this_plot->title) {
! 1795: localkey = 0;
! 1796: } else {
! 1797: if (localkey != 0 && this_plot->title) {
! 1798: key_count++;
! 1799: if (key_just == JLEFT) {
! 1800: (*t->justify_text) (LEFT);
! 1801: (*t->put_text) (xl + key_text_left,
! 1802: yl, this_plot->title);
! 1803: } else {
! 1804: if ((*t->justify_text) (RIGHT)) {
! 1805: (*t->put_text) (xl + key_text_right,
! 1806: yl, this_plot->title);
! 1807: } else {
! 1808: int x = xl + key_text_right - (t->h_char) * strlen(this_plot->title);
! 1809: if (key_hpos == TOUT ||
! 1810: i_inrange(x, xleft, xright))
! 1811: (*t->put_text) (x, yl, this_plot->title);
! 1812: }
! 1813: }
! 1814:
! 1815: /* draw sample depending on bits set in plot_style */
! 1816: if ((this_plot->plot_style & 1) ||
! 1817: ((this_plot->plot_style & 4) && this_plot->plot_type == DATA)) { /* errors for data plots only */
! 1818: (*t->move) (xl + key_sample_left, yl);
! 1819: (*t->vector) (xl + key_sample_right, yl);
! 1820: }
! 1821: /* oops - doing the point sample now breaks postscript
! 1822: * terminal for example, which changes current line style
! 1823: * when drawing a point, but does not restore it.
! 1824: * We simply draw the point sample after plotting
! 1825: */
! 1826:
! 1827: if (this_plot->plot_type == DATA &&
! 1828: (this_plot->plot_style & 4) &&
! 1829: bar_size > 0.0) {
! 1830: (*t->move) (xl + key_sample_left, yl + ERRORBARTIC);
! 1831: (*t->vector) (xl + key_sample_left, yl - ERRORBARTIC);
! 1832: (*t->move) (xl + key_sample_right, yl + ERRORBARTIC);
! 1833: (*t->vector) (xl + key_sample_right, yl - ERRORBARTIC);
! 1834: }
! 1835: }
! 1836: }
! 1837:
! 1838: /* and now the curves, plus any special key requirements */
! 1839: /* be sure to draw all lines before drawing any points */
! 1840:
! 1841: switch (this_plot->plot_style) {
! 1842: /*{{{ IMPULSE */
! 1843: case IMPULSES:
! 1844: plot_impulses(this_plot, axis_zero[y_axis], axis_zero[x_axis]);
! 1845: break;
! 1846: /*}}} */
! 1847: /*{{{ LINES */
! 1848: case LINES:
! 1849: plot_lines(this_plot);
! 1850: break;
! 1851: /*}}} */
! 1852: /*{{{ STEPS */
! 1853: case STEPS:
! 1854: plot_steps(this_plot);
! 1855: break;
! 1856: /*}}} */
! 1857: /*{{{ FSTEPS */
! 1858: case FSTEPS:
! 1859: plot_fsteps(this_plot);
! 1860: break;
! 1861: /*}}} */
! 1862: /*{{{ HISTEPS */
! 1863: case HISTEPS:
! 1864: plot_histeps(this_plot);
! 1865: break;
! 1866: /*}}} */
! 1867: /*{{{ POINTSTYLE */
! 1868: case POINTSTYLE:
! 1869: plot_points(this_plot);
! 1870: break;
! 1871: /*}}} */
! 1872: /*{{{ LINESPOINTS */
! 1873: case LINESPOINTS:
! 1874: plot_lines(this_plot);
! 1875: plot_points(this_plot);
! 1876: break;
! 1877: /*}}} */
! 1878: /*{{{ DOTS */
! 1879: case DOTS:
! 1880: if (localkey != 0 && this_plot->title) {
! 1881: (*t->point) (xl + key_point_offset, yl, -1);
! 1882: }
! 1883: plot_dots(this_plot);
! 1884: break;
! 1885: /*}}} */
! 1886: /*{{{ YERRORBARS */
! 1887: case YERRORBARS:{
! 1888: plot_bars(this_plot);
! 1889: plot_points(this_plot);
! 1890: break;
! 1891: }
! 1892: /*}}} */
! 1893: /*{{{ XERRORBARS */
! 1894: case XERRORBARS:{
! 1895: plot_bars(this_plot);
! 1896: plot_points(this_plot);
! 1897: }
! 1898: /*}}} */
! 1899: /*{{{ XYERRORBARS */
! 1900: case XYERRORBARS:
! 1901: plot_bars(this_plot);
! 1902: plot_points(this_plot);
! 1903: break;
! 1904:
! 1905: /*}}} */
! 1906: /*{{{ BOXXYERROR */
! 1907: case BOXXYERROR:
! 1908: plot_boxes(this_plot, axis_zero[x_axis]);
! 1909: break;
! 1910: /*}}} */
! 1911: /*{{{ BOXERROR (falls through to) */
! 1912: case BOXERROR:
! 1913: plot_bars(this_plot);
! 1914: /* no break */
! 1915:
! 1916: /*}}} */
! 1917: /*{{{ BOXES */
! 1918: case BOXES:
! 1919: plot_boxes(this_plot, axis_zero[x_axis]);
! 1920: break;
! 1921: /*}}} */
! 1922: /*{{{ VECTOR */
! 1923: case VECTOR:
! 1924: plot_vectors(this_plot);
! 1925: break;
! 1926:
! 1927: /*}}} */
! 1928: /*{{{ FINANCEBARS */
! 1929: case FINANCEBARS:
! 1930: plot_f_bars(this_plot);
! 1931: break;
! 1932: /*}}} */
! 1933: /*{{{ CANDLESTICKS */
! 1934: case CANDLESTICKS:
! 1935: plot_c_bars(this_plot);
! 1936: break;
! 1937: /*}}} */
! 1938: }
! 1939:
! 1940:
! 1941: if (localkey && this_plot->title) {
! 1942: /* we deferred point sample until now */
! 1943: if (this_plot->plot_style & 2)
! 1944: (*t->point) (xl + key_point_offset, yl,
! 1945: this_plot->lp_properties.p_type);
! 1946:
! 1947: if (key_count >= key_rows) {
! 1948: yl = yl_ref;
! 1949: xl += key_col_wth;
! 1950: key_count = 0;
! 1951: } else
! 1952: yl = yl - key_entry_height;
! 1953: }
! 1954: }
! 1955:
! 1956: term_end_plot();
! 1957: }
! 1958:
! 1959:
! 1960: /* BODGES */
! 1961: #undef ytic
! 1962: #undef xtic
! 1963:
! 1964: /* plot_impulses:
! 1965: * Plot the curves in IMPULSES style
! 1966: */
! 1967:
! 1968: static void plot_impulses(plot, yaxis_x, xaxis_y)
! 1969: struct curve_points *plot;
! 1970: int yaxis_x, xaxis_y;
! 1971: {
! 1972: int i;
! 1973: int x, y;
! 1974: struct termentry *t = term;
! 1975:
! 1976: for (i = 0; i < plot->p_count; i++) {
! 1977: switch (plot->points[i].type) {
! 1978: case INRANGE:{
! 1979: x = map_x(plot->points[i].x);
! 1980: y = map_y(plot->points[i].y);
! 1981: break;
! 1982: }
! 1983: case OUTRANGE:{
! 1984: if (!inrange(plot->points[i].x, x_min, x_max))
! 1985: continue;
! 1986: x = map_x(plot->points[i].x);
! 1987: if ((y_min < y_max
! 1988: && plot->points[i].y < y_min)
! 1989: || (y_max < y_min
! 1990: && plot->points[i].y > y_min))
! 1991: y = map_y(y_min);
! 1992: else
! 1993: y = map_y(y_max);
! 1994:
! 1995: break;
! 1996: }
! 1997: default: /* just a safety */
! 1998: case UNDEFINED:{
! 1999: continue;
! 2000: }
! 2001: }
! 2002:
! 2003: if (polar)
! 2004: (*t->move) (yaxis_x, xaxis_y);
! 2005: else
! 2006: (*t->move) (x, xaxis_y);
! 2007: (*t->vector) (x, y);
! 2008: }
! 2009:
! 2010: }
! 2011:
! 2012: /* plot_lines:
! 2013: * Plot the curves in LINES style
! 2014: */
! 2015: static void plot_lines(plot)
! 2016: struct curve_points *plot;
! 2017: {
! 2018: int i; /* point index */
! 2019: int x, y; /* point in terminal coordinates */
! 2020: struct termentry *t = term;
! 2021: enum coord_type prev = UNDEFINED; /* type of previous point */
! 2022: double ex, ey; /* an edge point */
! 2023: double lx[2], ly[2]; /* two edge points */
! 2024:
! 2025: for (i = 0; i < plot->p_count; i++) {
! 2026: switch (plot->points[i].type) {
! 2027: case INRANGE:{
! 2028: x = map_x(plot->points[i].x);
! 2029: y = map_y(plot->points[i].y);
! 2030:
! 2031: if (prev == INRANGE) {
! 2032: (*t->vector) (x, y);
! 2033: } else if (prev == OUTRANGE) {
! 2034: /* from outrange to inrange */
! 2035: if (!clip_lines1) {
! 2036: (*t->move) (x, y);
! 2037: } else {
! 2038: edge_intersect(plot->points, i, &ex, &ey);
! 2039: (*t->move) (map_x(ex), map_y(ey));
! 2040: (*t->vector) (x, y);
! 2041: }
! 2042: } else { /* prev == UNDEFINED */
! 2043: (*t->move) (x, y);
! 2044: (*t->vector) (x, y);
! 2045: }
! 2046:
! 2047: break;
! 2048: }
! 2049: case OUTRANGE:{
! 2050: if (prev == INRANGE) {
! 2051: /* from inrange to outrange */
! 2052: if (clip_lines1) {
! 2053: edge_intersect(plot->points, i, &ex, &ey);
! 2054: (*t->vector) (map_x(ex), map_y(ey));
! 2055: }
! 2056: } else if (prev == OUTRANGE) {
! 2057: /* from outrange to outrange */
! 2058: if (clip_lines2) {
! 2059: if (two_edge_intersect(plot->points, i, lx, ly)) {
! 2060: (*t->move) (map_x(lx[0]), map_y(ly[0]));
! 2061: (*t->vector) (map_x(lx[1]), map_y(ly[1]));
! 2062: }
! 2063: }
! 2064: }
! 2065: break;
! 2066: }
! 2067: default: /* just a safety */
! 2068: case UNDEFINED:{
! 2069: break;
! 2070: }
! 2071: }
! 2072: prev = plot->points[i].type;
! 2073: }
! 2074: }
! 2075:
! 2076: /* XXX - JG */
! 2077: /* plot_steps:
! 2078: * Plot the curves in STEPS style
! 2079: */
! 2080: static void plot_steps(plot)
! 2081: struct curve_points *plot;
! 2082: {
! 2083: int i; /* point index */
! 2084: int x, y; /* point in terminal coordinates */
! 2085: struct termentry *t = term;
! 2086: enum coord_type prev = UNDEFINED; /* type of previous point */
! 2087: double ex, ey; /* an edge point */
! 2088: double lx[2], ly[2]; /* two edge points */
! 2089: int yprev = 0; /* previous point coordinates */
! 2090:
! 2091: for (i = 0; i < plot->p_count; i++) {
! 2092: switch (plot->points[i].type) {
! 2093: case INRANGE:{
! 2094: x = map_x(plot->points[i].x);
! 2095: y = map_y(plot->points[i].y);
! 2096:
! 2097: if (prev == INRANGE) {
! 2098: (*t->vector) (x, yprev);
! 2099: (*t->vector) (x, y);
! 2100: } else if (prev == OUTRANGE) {
! 2101: /* from outrange to inrange */
! 2102: if (!clip_lines1) {
! 2103: (*t->move) (x, y);
! 2104: } else { /* find edge intersection */
! 2105: edge_intersect_steps(plot->points, i, &ex, &ey);
! 2106: (*t->move) (map_x(ex), map_y(ey));
! 2107: (*t->vector) (x, map_y(ey));
! 2108: (*t->vector) (x, y);
! 2109: }
! 2110: } else { /* prev == UNDEFINED */
! 2111: (*t->move) (x, y);
! 2112: (*t->vector) (x, y);
! 2113: }
! 2114: yprev = y;
! 2115: break;
! 2116: }
! 2117: case OUTRANGE:{
! 2118: if (prev == INRANGE) {
! 2119: /* from inrange to outrange */
! 2120: if (clip_lines1) {
! 2121: edge_intersect_steps(plot->points, i, &ex, &ey);
! 2122: (*t->vector) (map_x(ex), yprev);
! 2123: (*t->vector) (map_x(ex), map_y(ey));
! 2124: }
! 2125: } else if (prev == OUTRANGE) {
! 2126: /* from outrange to outrange */
! 2127: if (clip_lines2) {
! 2128: if (two_edge_intersect_steps(plot->points, i, lx, ly)) {
! 2129: (*t->move) (map_x(lx[0]), map_y(ly[0]));
! 2130: (*t->vector) (map_x(lx[1]), map_y(ly[0]));
! 2131: (*t->vector) (map_x(lx[1]), map_y(ly[1]));
! 2132: }
! 2133: }
! 2134: }
! 2135: break;
! 2136: }
! 2137: default: /* just a safety */
! 2138: case UNDEFINED:{
! 2139: break;
! 2140: }
! 2141: }
! 2142: prev = plot->points[i].type;
! 2143: }
! 2144: }
! 2145: /* XXX - HOE */
! 2146: /* plot_fsteps:
! 2147: * Plot the curves in STEPS style by step on forward yvalue
! 2148: */
! 2149: static void plot_fsteps(plot)
! 2150: struct curve_points *plot;
! 2151: {
! 2152: int i; /* point index */
! 2153: int x, y; /* point in terminal coordinates */
! 2154: struct termentry *t = term;
! 2155: enum coord_type prev = UNDEFINED; /* type of previous point */
! 2156: double ex, ey; /* an edge point */
! 2157: double lx[2], ly[2]; /* two edge points */
! 2158: int xprev = 0; /* previous point coordinates */
! 2159:
! 2160: for (i = 0; i < plot->p_count; i++) {
! 2161: switch (plot->points[i].type) {
! 2162: case INRANGE:{
! 2163: x = map_x(plot->points[i].x);
! 2164: y = map_y(plot->points[i].y);
! 2165:
! 2166: if (prev == INRANGE) {
! 2167: (*t->vector) (xprev, y);
! 2168: (*t->vector) (x, y);
! 2169: } else if (prev == OUTRANGE) {
! 2170: /* from outrange to inrange */
! 2171: if (!clip_lines1) {
! 2172: (*t->move) (x, y);
! 2173: } else { /* find edge intersection */
! 2174: edge_intersect_fsteps(plot->points, i, &ex, &ey);
! 2175: (*t->move) (map_x(ex), map_y(ey));
! 2176: (*t->vector) (map_x(ex), y);
! 2177: (*t->vector) (x, y);
! 2178: }
! 2179: } else { /* prev == UNDEFINED */
! 2180: (*t->move) (x, y);
! 2181: (*t->vector) (x, y);
! 2182: }
! 2183: xprev = x;
! 2184: break;
! 2185: }
! 2186: case OUTRANGE:{
! 2187: if (prev == INRANGE) {
! 2188: /* from inrange to outrange */
! 2189: if (clip_lines1) {
! 2190: edge_intersect_fsteps(plot->points, i, &ex, &ey);
! 2191: (*t->vector) (xprev, map_y(ey));
! 2192: (*t->vector) (map_x(ex), map_y(ey));
! 2193: }
! 2194: } else if (prev == OUTRANGE) {
! 2195: /* from outrange to outrange */
! 2196: if (clip_lines2) {
! 2197: if (two_edge_intersect_fsteps(plot->points, i, lx, ly)) {
! 2198: (*t->move) (map_x(lx[0]), map_y(ly[0]));
! 2199: (*t->vector) (map_x(lx[0]), map_y(ly[1]));
! 2200: (*t->vector) (map_x(lx[1]), map_y(ly[1]));
! 2201: }
! 2202: }
! 2203: }
! 2204: break;
! 2205: }
! 2206: default: /* just a safety */
! 2207: case UNDEFINED:{
! 2208: break;
! 2209: }
! 2210: }
! 2211: prev = plot->points[i].type;
! 2212: }
! 2213: }
! 2214:
! 2215: /* CAC */
! 2216: /* plot_histeps:
! 2217: * Plot the curves in HISTEPS style
! 2218: */
! 2219: static void plot_histeps(plot)
! 2220: struct curve_points *plot;
! 2221: {
! 2222: int i; /* point index */
! 2223: int hold, bigi; /* indices for sorting */
! 2224: int xl, yl; /* cursor position in terminal coordinates */
! 2225: struct termentry *t = term;
! 2226: double x, y, xn, yn; /* point position */
! 2227: int *gl, goodcount; /* array to hold list of valid points */
! 2228:
! 2229: /* preliminary count of points inside array */
! 2230: goodcount = 0;
! 2231: for (i = 0; i < plot->p_count; i++)
! 2232: if (plot->points[i].type == INRANGE ||
! 2233: plot->points[i].type == OUTRANGE)
! 2234: ++goodcount;
! 2235: if (goodcount < 2)
! 2236: return; /* cannot plot less than 2 points */
! 2237:
! 2238: gl = (int *) gp_alloc(goodcount * sizeof(int), "histeps valid point mapping");
! 2239: if (gl == NULL)
! 2240: return;
! 2241:
! 2242: /* fill gl array with indexes of valid (non-undefined) points. */
! 2243: goodcount = 0;
! 2244: for (i = 0; i < plot->p_count; i++)
! 2245: if (plot->points[i].type == INRANGE ||
! 2246: plot->points[i].type == OUTRANGE) {
! 2247: gl[goodcount] = i;
! 2248: ++goodcount;
! 2249: }
! 2250: /* sort the data */
! 2251: for (bigi = i = 1; i < goodcount;) {
! 2252: if (plot->points[gl[i]].x < plot->points[gl[i - 1]].x) {
! 2253: hold = gl[i];
! 2254: gl[i] = gl[i - 1];
! 2255: gl[i - 1] = hold;
! 2256: if (i > 1) {
! 2257: i--;
! 2258: continue;
! 2259: }
! 2260: }
! 2261: i = ++bigi;
! 2262: }
! 2263:
! 2264: x = (3.0 * plot->points[gl[0]].x - plot->points[gl[1]].x) / 2.0;
! 2265: y = 0.0;
! 2266:
! 2267: xl = map_x(x);
! 2268: yl = map_y(y);
! 2269: (*t->move) (xl, yl);
! 2270:
! 2271: for (i = 0; i < goodcount - 1; i++) { /* loop over all points except last */
! 2272:
! 2273: yn = plot->points[gl[i]].y;
! 2274: xn = (plot->points[gl[i]].x + plot->points[gl[i + 1]].x) / 2.0;
! 2275: histeps_vertical(&xl, &yl, x, y, yn);
! 2276: histeps_horizontal(&xl, &yl, x, xn, yn);
! 2277:
! 2278: x = xn;
! 2279: y = yn;
! 2280: }
! 2281:
! 2282: yn = plot->points[gl[i]].y;
! 2283: xn = (3.0 * plot->points[gl[i]].x - plot->points[gl[i - 1]].x) / 2.0;
! 2284: histeps_vertical(&xl, &yl, x, y, yn);
! 2285: histeps_horizontal(&xl, &yl, x, xn, yn);
! 2286: histeps_vertical(&xl, &yl, xn, yn, 0.0);
! 2287:
! 2288: free(gl);
! 2289: }
! 2290: /* CAC
! 2291: * Draw vertical line for the histeps routine.
! 2292: * Performs clipping.
! 2293: */
! 2294: static void histeps_vertical(xl, yl, x, y1, y2)
! 2295: int *xl, *yl; /* keeps track of "cursor" position */
! 2296: double x, y1, y2; /* coordinates of vertical line */
! 2297: {
! 2298: struct termentry *t = term;
! 2299: /* global x_min, x_max, y_min, y_max */
! 2300: int xm, y1m, y2m;
! 2301:
! 2302: if ((y1 < y_min && y2 < y_min) ||
! 2303: (y1 > y_max && y2 > y_max) ||
! 2304: x < x_min ||
! 2305: x > x_max)
! 2306: return;
! 2307:
! 2308: if (y1 < y_min)
! 2309: y1 = y_min;
! 2310: if (y1 > y_max)
! 2311: y1 = y_max;
! 2312: if (y2 < y_min)
! 2313: y2 = y_min;
! 2314: if (y2 > y_max)
! 2315: y2 = y_max;
! 2316:
! 2317: xm = map_x(x);
! 2318: y1m = map_y(y1);
! 2319: y2m = map_y(y2);
! 2320:
! 2321: if (y1m != *yl || xm != *xl)
! 2322: (*t->move) (xm, y1m);
! 2323: (*t->vector) (xm, y2m);
! 2324: *xl = xm;
! 2325: *yl = y2m;
! 2326:
! 2327: return;
! 2328: }
! 2329: /* CAC
! 2330: * Draw horizontal line for the histeps routine.
! 2331: * Performs clipping.
! 2332: */
! 2333: static void histeps_horizontal(xl, yl, x1, x2, y)
! 2334: int *xl, *yl; /* keeps track of "cursor" position */
! 2335: double x1, x2, y; /* coordinates of vertical line */
! 2336: {
! 2337: struct termentry *t = term;
! 2338: /* global x_min, x_max, y_min, y_max */
! 2339: int x1m, x2m, ym;
! 2340:
! 2341: if ((x1 < x_min && x2 < x_min) ||
! 2342: (x1 > x_max && x2 > x_max) ||
! 2343: y < y_min ||
! 2344: y > y_max)
! 2345: return;
! 2346:
! 2347: if (x1 < x_min)
! 2348: x1 = x_min;
! 2349: if (x1 > x_max)
! 2350: x1 = x_max;
! 2351: if (x2 < x_min)
! 2352: x2 = x_min;
! 2353: if (x2 > x_max)
! 2354: x2 = x_max;
! 2355:
! 2356: ym = map_y(y);
! 2357: x1m = map_x(x1);
! 2358: x2m = map_x(x2);
! 2359:
! 2360: if (x1m != *xl || ym != *yl)
! 2361: (*t->move) (x1m, ym);
! 2362: (*t->vector) (x2m, ym);
! 2363: *xl = x2m;
! 2364: *yl = ym;
! 2365:
! 2366: return;
! 2367: }
! 2368:
! 2369:
! 2370: /* plot_bars:
! 2371: * Plot the curves in ERRORBARS style
! 2372: * we just plot the bars; the points are plotted in plot_points
! 2373: */
! 2374: static void plot_bars(plot)
! 2375: struct curve_points *plot;
! 2376: {
! 2377: int i; /* point index */
! 2378: struct termentry *t = term;
! 2379: double x, y; /* position of the bar */
! 2380: double ylow, yhigh; /* the ends of the bars */
! 2381: double xlow, xhigh;
! 2382: double x1, y1, x2, y2, slope; /* parameters for polar error bars */
! 2383: unsigned int xM, ylowM, yhighM; /* the mapped version of above */
! 2384: unsigned int yM, xlowM, xhighM;
! 2385: TBOOLEAN low_inrange, high_inrange;
! 2386: int tic = ERRORBARTIC;
! 2387:
! 2388: /* Limitation: no boxes with x errorbars */
! 2389:
! 2390: if ((plot->plot_style == YERRORBARS) || (plot->plot_style == XYERRORBARS) ||
! 2391: (plot->plot_style == BOXERROR)) {
! 2392: /* Draw the vertical part of the bar */
! 2393: for (i = 0; i < plot->p_count; i++) {
! 2394: /* undefined points don't count */
! 2395: if (plot->points[i].type == UNDEFINED)
! 2396: continue;
! 2397:
! 2398: /* check to see if in xrange */
! 2399: x = plot->points[i].x;
! 2400: if (!inrange(x, x_min, x_max))
! 2401: continue;
! 2402: xM = map_x(x);
! 2403:
! 2404: /* check to see if in yrange */
! 2405: y = plot->points[i].y;
! 2406: if (!inrange(y, y_min, y_max))
! 2407: continue;
! 2408: yM = map_y(y);
! 2409:
! 2410: /* find low and high points of bar, and check yrange */
! 2411: yhigh = plot->points[i].yhigh;
! 2412: ylow = plot->points[i].ylow;
! 2413:
! 2414: high_inrange = inrange(yhigh, y_min, y_max);
! 2415: low_inrange = inrange(ylow, y_min, y_max);
! 2416:
! 2417: /* compute the plot position of yhigh */
! 2418: if (high_inrange)
! 2419: yhighM = map_y(yhigh);
! 2420: else if (samesign(yhigh - y_max, y_max - y_min))
! 2421: yhighM = map_y(y_max);
! 2422: else
! 2423: yhighM = map_y(y_min);
! 2424:
! 2425: /* compute the plot position of ylow */
! 2426: if (low_inrange)
! 2427: ylowM = map_y(ylow);
! 2428: else if (samesign(ylow - y_max, y_max - y_min))
! 2429: ylowM = map_y(y_max);
! 2430: else
! 2431: ylowM = map_y(y_min);
! 2432:
! 2433: if (!high_inrange && !low_inrange && ylowM == yhighM)
! 2434: /* both out of range on the same side */
! 2435: continue;
! 2436:
! 2437: /* find low and high points of bar, and check xrange */
! 2438: xhigh = plot->points[i].xhigh;
! 2439: xlow = plot->points[i].xlow;
! 2440:
! 2441: high_inrange = inrange(xhigh, x_min, x_max);
! 2442: low_inrange = inrange(xlow, x_min, x_max);
! 2443:
! 2444: /* compute the plot position of xhigh */
! 2445: if (high_inrange)
! 2446: xhighM = map_x(xhigh);
! 2447: else if (samesign(xhigh - x_max, x_max - x_min))
! 2448: xhighM = map_x(x_max);
! 2449: else
! 2450: xhighM = map_x(x_min);
! 2451:
! 2452: /* compute the plot position of xlow */
! 2453: if (low_inrange)
! 2454: xlowM = map_x(xlow);
! 2455: else if (samesign(xlow - x_max, x_max - x_min))
! 2456: xlowM = map_x(x_max);
! 2457: else
! 2458: xlowM = map_x(x_min);
! 2459:
! 2460: if (!high_inrange && !low_inrange && xlowM == xhighM)
! 2461: /* both out of range on the same side */
! 2462: continue;
! 2463:
! 2464: /* by here everything has been mapped */
! 2465: if (!polar) {
! 2466: /* HBB 981130: use Igor's routine *only* for polar errorbars */
! 2467: (*t->move) (xM, ylowM);
! 2468: /* draw the main bar */
! 2469: (*t->vector) (xM, yhighM);
! 2470: if (bar_size > 0.0) {
! 2471: /* draw the bottom tic */
! 2472: (*t->move) ((unsigned int) (xM - bar_size * tic), ylowM);
! 2473: (*t->vector) ((unsigned int) (xM + bar_size * tic), ylowM);
! 2474: /* draw the top tic */
! 2475: (*t->move) ((unsigned int) (xM - bar_size * tic), yhighM);
! 2476: (*t->vector) ((unsigned int) (xM + bar_size * tic), yhighM);
! 2477: }
! 2478: } else {
! 2479: /* HBB 981130: see above */
! 2480: /* The above has been replaced by Igor inorder to get errorbars
! 2481: coming out in polar mode AND to stop the bar from going
! 2482: through the symbol */
! 2483: if ((xhighM - xlowM) * (xhighM - xlowM) + (yhighM - ylowM) * (yhighM - ylowM)
! 2484: > pointsize * tic * pointsize * tic * 4.5) {
! 2485: /* Only plot the error bar if it is bigger than the
! 2486: * symbol */
! 2487: /* The factor of 4.5 should strictly be 4.0, but it looks
! 2488: * better to drop the error bar if it is only slightly
! 2489: * bigger than the symbol, Igor. */
! 2490: if (xlowM == xhighM) {
! 2491: (*t->move) (xM, ylowM);
! 2492: /* draw the main bar to the symbol end */
! 2493: (*t->vector) (xM, (unsigned int) (yM - pointsize * tic));
! 2494: (*t->move) (xM, (unsigned int) (yM + pointsize * tic));
! 2495: /* draw the other part of the main bar */
! 2496: (*t->vector) (xM, yhighM);
! 2497: } else {
! 2498: (*t->move) (xlowM, ylowM);
! 2499: /* draw the main bar in polar mode. Note that here
! 2500: * the bar is drawn through the symbol. I tried to
! 2501: * fix this, but got into trouble with the two bars
! 2502: * (on either side of symbol) not being perfectly
! 2503: * parallel due to mapping considerations. Igor
! 2504: */
! 2505: (*t->vector) (xhighM, yhighM);
! 2506: }
! 2507: if (bar_size > 0.0) {
! 2508: /* The following attempts to ensure that the tics
! 2509: * are perpendicular to the error bar, Igor. */
! 2510: /*perpendicular to the main bar */
! 2511: slope = (xlowM * 1.0 - xhighM * 1.0) / (yhighM * 1.0 - ylowM * 1.0 + 1e-10);
! 2512: x1 = xlowM + bar_size * tic / sqrt(1.0 + slope * slope);
! 2513: x2 = xlowM - bar_size * tic / sqrt(1.0 + slope * slope);
! 2514: y1 = slope * (x1 - xlowM) + ylowM;
! 2515: y2 = slope * (x2 - xlowM) + ylowM;
! 2516:
! 2517: /* draw the bottom tic */
! 2518: (*t->move) ((unsigned int) x1, (unsigned int) y1);
! 2519: (*t->vector) ((unsigned int) x2, (unsigned int) y2);
! 2520:
! 2521: x1 = xhighM + bar_size * tic / sqrt(1.0 + slope * slope);
! 2522: x2 = xhighM - bar_size * tic / sqrt(1.0 + slope * slope);
! 2523: y1 = slope * (x1 - xhighM) + yhighM;
! 2524: y2 = slope * (x2 - xhighM) + yhighM;
! 2525: /* draw the top tic */
! 2526: (*t->move) ((unsigned int) x1, (unsigned int) y1);
! 2527: (*t->vector) ((unsigned int) x2, (unsigned int) y2);
! 2528: } /* if error bar is bigger than symbol */
! 2529: }
! 2530: } /* HBB 981130: see above */
! 2531: } /* for loop */
! 2532: } /* if yerrorbars OR xyerrorbars */
! 2533: if ((plot->plot_style == XERRORBARS) || (plot->plot_style == XYERRORBARS)) {
! 2534:
! 2535: /* Draw the horizontal part of the bar */
! 2536: for (i = 0; i < plot->p_count; i++) {
! 2537: /* undefined points don't count */
! 2538: if (plot->points[i].type == UNDEFINED)
! 2539: continue;
! 2540:
! 2541: /* check to see if in yrange */
! 2542: y = plot->points[i].y;
! 2543: if (!inrange(y, y_min, y_max))
! 2544: continue;
! 2545: yM = map_y(y);
! 2546:
! 2547: /* find low and high points of bar, and check xrange */
! 2548: xhigh = plot->points[i].xhigh;
! 2549: xlow = plot->points[i].xlow;
! 2550:
! 2551: high_inrange = inrange(xhigh, x_min, x_max);
! 2552: low_inrange = inrange(xlow, x_min, x_max);
! 2553:
! 2554: /* compute the plot position of xhigh */
! 2555: if (high_inrange)
! 2556: xhighM = map_x(xhigh);
! 2557: else if (samesign(xhigh - x_max, x_max - x_min))
! 2558: xhighM = map_x(x_max);
! 2559: else
! 2560: xhighM = map_x(x_min);
! 2561:
! 2562: /* compute the plot position of xlow */
! 2563: if (low_inrange)
! 2564: xlowM = map_x(xlow);
! 2565: else if (samesign(xlow - x_max, x_max - x_min))
! 2566: xlowM = map_x(x_max);
! 2567: else
! 2568: xlowM = map_x(x_min);
! 2569:
! 2570: if (!high_inrange && !low_inrange && xlowM == xhighM)
! 2571: /* both out of range on the same side */
! 2572: continue;
! 2573:
! 2574: /* by here everything has been mapped */
! 2575: (*t->move) (xlowM, yM);
! 2576: (*t->vector) (xhighM, yM); /* draw the main bar */
! 2577: if (bar_size > 0.0) {
! 2578: (*t->move) (xlowM, (unsigned int) (yM - bar_size * tic)); /* draw the left tic */
! 2579: (*t->vector) (xlowM, (unsigned int) (yM + bar_size * tic));
! 2580: (*t->move) (xhighM, (unsigned int) (yM - bar_size * tic)); /* draw the right tic */
! 2581: (*t->vector) (xhighM, (unsigned int) (yM + bar_size * tic));
! 2582: }
! 2583: } /* for loop */
! 2584: } /* if xerrorbars OR xyerrorbars */
! 2585: }
! 2586:
! 2587: /* plot_boxes:
! 2588: * Plot the curves in BOXES style
! 2589: */
! 2590: static void plot_boxes(plot, xaxis_y)
! 2591: struct curve_points *plot;
! 2592: int xaxis_y;
! 2593: {
! 2594: int i; /* point index */
! 2595: int xl, xr, yt; /* point in terminal coordinates */
! 2596: double dxl, dxr, dyt;
! 2597: struct termentry *t = term;
! 2598: enum coord_type prev = UNDEFINED; /* type of previous point */
! 2599: TBOOLEAN boxxy = (plot->plot_style == BOXXYERROR);
! 2600:
! 2601: for (i = 0; i < plot->p_count; i++) {
! 2602:
! 2603: switch (plot->points[i].type) {
! 2604: case OUTRANGE:
! 2605: case INRANGE:{
! 2606: if (plot->points[i].z < 0.0) {
! 2607: /* need to auto-calc width */
! 2608: /* ASSERT(boxwidth <= 0.0); - else graphics.c
! 2609: * provides width */
! 2610:
! 2611: /* calculate width */
! 2612: if (prev != UNDEFINED)
! 2613: dxl = (plot->points[i - 1].x - plot->points[i].x) / 2.0;
! 2614: else
! 2615: dxl = 0.0;
! 2616:
! 2617: if (i < plot->p_count - 1) {
! 2618: if (plot->points[i + 1].type != UNDEFINED)
! 2619: dxr = (plot->points[i + 1].x - plot->points[i].x) / 2.0;
! 2620: else
! 2621: dxr = -dxl;
! 2622: } else {
! 2623: dxr = -dxl;
! 2624: }
! 2625:
! 2626: if (prev == UNDEFINED)
! 2627: dxl = -dxr;
! 2628:
! 2629: dxl = plot->points[i].x + dxl;
! 2630: dxr = plot->points[i].x + dxr;
! 2631: } else { /* z >= 0 */
! 2632: dxr = plot->points[i].xhigh;
! 2633: dxl = plot->points[i].xlow;
! 2634: }
! 2635:
! 2636: if (boxxy) {
! 2637: dyt = plot->points[i].yhigh;
! 2638: xaxis_y = map_y(plot->points[i].ylow);
! 2639: } else {
! 2640: dyt = plot->points[i].y;
! 2641: }
! 2642:
! 2643: /* clip to border */
! 2644: if ((y_min < y_max && dyt < y_min)
! 2645: || (y_max < y_min && dyt > y_min))
! 2646: dyt = y_min;
! 2647: if ((y_min < y_max && dyt > y_max)
! 2648: || (y_max < y_min && dyt < y_max))
! 2649: dyt = y_max;
! 2650: if ((x_min < x_max && dxr < x_min)
! 2651: || (x_max < x_min && dxr > x_min))
! 2652: dxr = x_min;
! 2653: if ((x_min < x_max && dxr > x_max)
! 2654: || (x_max < x_min && dxr < x_max))
! 2655: dxr = x_max;
! 2656: if ((x_min < x_max && dxl < x_min)
! 2657: || (x_max < x_min && dxl > x_min))
! 2658: dxl = x_min;
! 2659: if ((x_min < x_max && dxl > x_max)
! 2660: || (x_max < x_min && dxl < x_max))
! 2661: dxl = x_max;
! 2662:
! 2663: xl = map_x(dxl);
! 2664: xr = map_x(dxr);
! 2665: yt = map_y(dyt);
! 2666:
! 2667: (*t->move) (xl, xaxis_y);
! 2668: (*t->vector) (xl, yt);
! 2669: (*t->vector) (xr, yt);
! 2670: (*t->vector) (xr, xaxis_y);
! 2671: (*t->vector) (xl, xaxis_y);
! 2672: break;
! 2673: } /* case OUTRANGE, INRANGE */
! 2674:
! 2675: default: /* just a safety */
! 2676: case UNDEFINED:{
! 2677: break;
! 2678: }
! 2679:
! 2680: } /* switch point-type */
! 2681:
! 2682: prev = plot->points[i].type;
! 2683:
! 2684: } /*loop */
! 2685: }
! 2686:
! 2687:
! 2688:
! 2689: /* plot_points:
! 2690: * Plot the curves in POINTSTYLE style
! 2691: */
! 2692: static void plot_points(plot)
! 2693: struct curve_points *plot;
! 2694: {
! 2695: int i;
! 2696: int x, y;
! 2697: struct termentry *t = term;
! 2698:
! 2699: for (i = 0; i < plot->p_count; i++) {
! 2700: if (plot->points[i].type == INRANGE) {
! 2701: x = map_x(plot->points[i].x);
! 2702: y = map_y(plot->points[i].y);
! 2703: /* do clipping if necessary */
! 2704: if (!clip_points ||
! 2705: (x >= xleft + p_width && y >= ybot + p_height
! 2706: && x <= xright - p_width && y <= ytop - p_height))
! 2707: (*t->point) (x, y, plot->lp_properties.p_type);
! 2708: }
! 2709: }
! 2710: }
! 2711:
! 2712: /* plot_dots:
! 2713: * Plot the curves in DOTS style
! 2714: */
! 2715: static void plot_dots(plot)
! 2716: struct curve_points *plot;
! 2717: {
! 2718: int i;
! 2719: int x, y;
! 2720: struct termentry *t = term;
! 2721:
! 2722: for (i = 0; i < plot->p_count; i++) {
! 2723: if (plot->points[i].type == INRANGE) {
! 2724: x = map_x(plot->points[i].x);
! 2725: y = map_y(plot->points[i].y);
! 2726: /* point type -1 is a dot */
! 2727: (*t->point) (x, y, -1);
! 2728: }
! 2729: }
! 2730: }
! 2731:
! 2732: /* plot_vectors:
! 2733: * Plot the curves in VECTORS style
! 2734: */
! 2735: static void plot_vectors(plot)
! 2736: struct curve_points *plot;
! 2737: {
! 2738: int i;
! 2739: int x1, y1, x2, y2;
! 2740: struct termentry *t = term;
! 2741:
! 2742: for (i = 0; i < plot->p_count; i++) {
! 2743: if (plot->points[i].type == INRANGE) {
! 2744: x1 = map_x(plot->points[i].xlow);
! 2745: y1 = map_y(plot->points[i].ylow);
! 2746: x2 = map_x(plot->points[i].xhigh);
! 2747: y2 = map_y(plot->points[i].yhigh);
! 2748: (*t->arrow) (x1, y1, x2, y2, TRUE);
! 2749: }
! 2750: }
! 2751: }
! 2752:
! 2753:
! 2754: /* plot_f_bars() - finance bars */
! 2755: static void plot_f_bars(plot)
! 2756: struct curve_points *plot;
! 2757: {
! 2758: int i; /* point index */
! 2759: struct termentry *t = term;
! 2760: double x; /* position of the bar */
! 2761: double ylow, yhigh, yclose, yopen; /* the ends of the bars */
! 2762: unsigned int xM, ylowM, yhighM; /* the mapped version of above */
! 2763: TBOOLEAN low_inrange, high_inrange;
! 2764: int tic = ERRORBARTIC / 2;
! 2765:
! 2766: for (i = 0; i < plot->p_count; i++) {
! 2767: /* undefined points don't count */
! 2768: if (plot->points[i].type == UNDEFINED)
! 2769: continue;
! 2770:
! 2771: /* check to see if in xrange */
! 2772: x = plot->points[i].x;
! 2773: if (!inrange(x, x_min, x_max))
! 2774: continue;
! 2775: xM = map_x(x);
! 2776:
! 2777: /* find low and high points of bar, and check yrange */
! 2778: yhigh = plot->points[i].yhigh;
! 2779: ylow = plot->points[i].ylow;
! 2780: yclose = plot->points[i].z;
! 2781: yopen = plot->points[i].y;
! 2782:
! 2783: high_inrange = inrange(yhigh, y_min, y_max);
! 2784: low_inrange = inrange(ylow, y_min, y_max);
! 2785:
! 2786: /* compute the plot position of yhigh */
! 2787: if (high_inrange)
! 2788: yhighM = map_y(yhigh);
! 2789: else if (samesign(yhigh - y_max, y_max - y_min))
! 2790: yhighM = map_y(y_max);
! 2791: else
! 2792: yhighM = map_y(y_min);
! 2793:
! 2794: /* compute the plot position of ylow */
! 2795: if (low_inrange)
! 2796: ylowM = map_y(ylow);
! 2797: else if (samesign(ylow - y_max, y_max - y_min))
! 2798: ylowM = map_y(y_max);
! 2799: else
! 2800: ylowM = map_y(y_min);
! 2801:
! 2802: if (!high_inrange && !low_inrange && ylowM == yhighM)
! 2803: /* both out of range on the same side */
! 2804: continue;
! 2805:
! 2806: /* by here everything has been mapped */
! 2807: (*t->move) (xM, ylowM);
! 2808: (*t->vector) (xM, yhighM); /* draw the main bar */
! 2809: /* draw the open tic */
! 2810: (*t->move) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
! 2811: (*t->vector) (xM, map_y(yopen));
! 2812: /* draw the close tic */
! 2813: (*t->move) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
! 2814: (*t->vector) (xM, map_y(yclose));
! 2815: }
! 2816: }
! 2817:
! 2818:
! 2819: /* plot_c_bars:
! 2820: * Plot the curves in CANDLESTICSK style
! 2821: * we just plot the bars; the points are not plotted
! 2822: */
! 2823: static void plot_c_bars(plot)
! 2824: struct curve_points *plot;
! 2825: {
! 2826: int i; /* point index */
! 2827: struct termentry *t = term;
! 2828: double x; /* position of the bar */
! 2829: double ylow, yhigh, yclose, yopen; /* the ends of the bars */
! 2830: unsigned int xM, ylowM, yhighM; /* the mapped version of above */
! 2831: TBOOLEAN low_inrange, high_inrange;
! 2832: int tic = ERRORBARTIC / 2;
! 2833:
! 2834: for (i = 0; i < plot->p_count; i++) {
! 2835: /* undefined points don't count */
! 2836: if (plot->points[i].type == UNDEFINED)
! 2837: continue;
! 2838:
! 2839: /* check to see if in xrange */
! 2840: x = plot->points[i].x;
! 2841: if (!inrange(x, x_min, x_max))
! 2842: continue;
! 2843: xM = map_x(x);
! 2844:
! 2845: /* find low and high points of bar, and check yrange */
! 2846: yhigh = plot->points[i].yhigh;
! 2847: ylow = plot->points[i].ylow;
! 2848: yclose = plot->points[i].z;
! 2849: yopen = plot->points[i].y;
! 2850:
! 2851: high_inrange = inrange(yhigh, y_min, y_max);
! 2852: low_inrange = inrange(ylow, y_min, y_max);
! 2853:
! 2854: /* compute the plot position of yhigh */
! 2855: if (high_inrange)
! 2856: yhighM = map_y(yhigh);
! 2857: else if (samesign(yhigh - y_max, y_max - y_min))
! 2858: yhighM = map_y(y_max);
! 2859: else
! 2860: yhighM = map_y(y_min);
! 2861:
! 2862: /* compute the plot position of ylow */
! 2863: if (low_inrange)
! 2864: ylowM = map_y(ylow);
! 2865: else if (samesign(ylow - y_max, y_max - y_min))
! 2866: ylowM = map_y(y_max);
! 2867: else
! 2868: ylowM = map_y(y_min);
! 2869:
! 2870: if (!high_inrange && !low_inrange && ylowM == yhighM)
! 2871: /* both out of range on the same side */
! 2872: continue;
! 2873:
! 2874: /* by here everything has been mapped */
! 2875: if (yopen <= yclose) {
! 2876: (*t->move) (xM, ylowM);
! 2877: (*t->vector) (xM, map_y(yopen)); /* draw the lower bar */
! 2878: /* draw the open tic */
! 2879: (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
! 2880: /* draw the open tic */
! 2881: (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yopen));
! 2882: (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
! 2883: (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yclose));
! 2884: /* draw the open tic */
! 2885: (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
! 2886: (*t->move) (xM, map_y(yclose)); /* draw the close tic */
! 2887: (*t->vector) (xM, yhighM);
! 2888: } else {
! 2889: (*t->move) (xM, ylowM);
! 2890: (*t->vector) (xM, yhighM);
! 2891: /* draw the open tic */
! 2892: (*t->move) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
! 2893: /* draw the open tic */
! 2894: (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yopen));
! 2895: (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
! 2896: (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yclose));
! 2897: /* draw the open tic */
! 2898: (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
! 2899: /* draw the close tic */
! 2900: (*t->move) ((unsigned int) (xM - bar_size * tic / 2), map_y(yclose));
! 2901: /* draw the open tic */
! 2902: (*t->vector) ((unsigned int) (xM - bar_size * tic / 2), map_y(yopen));
! 2903: /* draw the close tic */
! 2904: (*t->move) ((unsigned int) (xM + bar_size * tic / 2), map_y(yclose));
! 2905: /* draw the open tic */
! 2906: (*t->vector) ((unsigned int) (xM + bar_size * tic / 2), map_y(yopen));
! 2907: }
! 2908:
! 2909: }
! 2910: }
! 2911:
! 2912: /* single edge intersection algorithm */
! 2913: /* Given two points, one inside and one outside the plot, return
! 2914: * the point where an edge of the plot intersects the line segment defined
! 2915: * by the two points.
! 2916: */
! 2917: static void edge_intersect(points, i, ex, ey)
! 2918: struct coordinate GPHUGE *points; /* the points array */
! 2919: int i; /* line segment from point i-1 to point i */
! 2920: double *ex, *ey; /* the point where it crosses an edge */
! 2921: {
! 2922: /* global x_min, x_max, y_min, x_max */
! 2923: double ix = points[i - 1].x;
! 2924: double iy = points[i - 1].y;
! 2925: double ox = points[i].x;
! 2926: double oy = points[i].y;
! 2927: double x, y; /* possible intersection point */
! 2928:
! 2929: if (points[i].type == INRANGE) {
! 2930: /* swap points around so that ix/ix/iz are INRANGE and
! 2931: * ox/oy/oz are OUTRANGE
! 2932: */
! 2933: x = ix;
! 2934: ix = ox;
! 2935: ox = x;
! 2936: y = iy;
! 2937: iy = oy;
! 2938: oy = y;
! 2939: }
! 2940: /* nasty degenerate cases, effectively drawing to an infinity point (?)
! 2941: * cope with them here, so don't process them as a "real" OUTRANGE point
! 2942: *
! 2943: * If more than one coord is -VERYLARGE, then can't ratio the "infinities"
! 2944: * so drop out by returning the INRANGE point.
! 2945: *
! 2946: * Obviously, only need to test the OUTRANGE point (coordinates) */
! 2947: if (ox == -VERYLARGE || oy == -VERYLARGE) {
! 2948: *ex = ix;
! 2949: *ey = iy;
! 2950:
! 2951: if (ox == -VERYLARGE) {
! 2952: /* can't get a direction to draw line, so simply
! 2953: * return INRANGE point */
! 2954: if (oy == -VERYLARGE)
! 2955: return;
! 2956:
! 2957: *ex = x_min;
! 2958: return;
! 2959: }
! 2960: /* obviously oy is -VERYLARGE and ox != -VERYLARGE */
! 2961: *ey = y_min;
! 2962: return;
! 2963: }
! 2964: /*
! 2965: * Can't have case (ix == ox && iy == oy) as one point
! 2966: * is INRANGE and one point is OUTRANGE.
! 2967: */
! 2968: if (iy == oy) {
! 2969: /* horizontal line */
! 2970: /* assume inrange(iy, y_min, y_max) */
! 2971: *ey = iy; /* == oy */
! 2972:
! 2973: if (inrange(x_max, ix, ox))
! 2974: *ex = x_max;
! 2975: else if (inrange(x_min, ix, ox))
! 2976: *ex = x_min;
! 2977: else {
! 2978: graph_error("error in edge_intersect");
! 2979: }
! 2980: return;
! 2981: } else if (ix == ox) {
! 2982: /* vertical line */
! 2983: /* assume inrange(ix, x_min, x_max) */
! 2984: *ex = ix; /* == ox */
! 2985:
! 2986: if (inrange(y_max, iy, oy))
! 2987: *ey = y_max;
! 2988: else if (inrange(y_min, iy, oy))
! 2989: *ey = y_min;
! 2990: else {
! 2991: graph_error("error in edge_intersect");
! 2992: }
! 2993: return;
! 2994: }
! 2995: /* slanted line of some kind */
! 2996:
! 2997: /* does it intersect y_min edge */
! 2998: if (inrange(y_min, iy, oy) && y_min != iy && y_min != oy) {
! 2999: x = ix + (y_min - iy) * ((ox - ix) / (oy - iy));
! 3000: if (inrange(x, x_min, x_max)) {
! 3001: *ex = x;
! 3002: *ey = y_min;
! 3003: return; /* yes */
! 3004: }
! 3005: }
! 3006: /* does it intersect y_max edge */
! 3007: if (inrange(y_max, iy, oy) && y_max != iy && y_max != oy) {
! 3008: x = ix + (y_max - iy) * ((ox - ix) / (oy - iy));
! 3009: if (inrange(x, x_min, x_max)) {
! 3010: *ex = x;
! 3011: *ey = y_max;
! 3012: return; /* yes */
! 3013: }
! 3014: }
! 3015: /* does it intersect x_min edge */
! 3016: if (inrange(x_min, ix, ox) && x_min != ix && x_min != ox) {
! 3017: y = iy + (x_min - ix) * ((oy - iy) / (ox - ix));
! 3018: if (inrange(y, y_min, y_max)) {
! 3019: *ex = x_min;
! 3020: *ey = y;
! 3021: return;
! 3022: }
! 3023: }
! 3024: /* does it intersect x_max edge */
! 3025: if (inrange(x_max, ix, ox) && x_max != ix && x_max != ox) {
! 3026: y = iy + (x_max - ix) * ((oy - iy) / (ox - ix));
! 3027: if (inrange(y, y_min, y_max)) {
! 3028: *ex = x_max;
! 3029: *ey = y;
! 3030: return;
! 3031: }
! 3032: }
! 3033: /* If we reach here, the inrange point is on the edge, and
! 3034: * the line segment from the outrange point does not cross any
! 3035: * other edges to get there. In this case, we return the inrange
! 3036: * point as the 'edge' intersection point. This will basically draw
! 3037: * line.
! 3038: */
! 3039: *ex = ix;
! 3040: *ey = iy;
! 3041: return;
! 3042: }
! 3043:
! 3044: /* XXX - JG */
! 3045: /* single edge intersection algorithm for "steps" curves */
! 3046: /*
! 3047: * Given two points, one inside and one outside the plot, return
! 3048: * the point where an edge of the plot intersects the line segments
! 3049: * forming the step between the two points.
! 3050: *
! 3051: * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
! 3052: * P1 to P2 is drawn as two line segments: (x1,y1)->(x2,y1) and
! 3053: * (x2,y1)->(x2,y2).
! 3054: */
! 3055: static void edge_intersect_steps(points, i, ex, ey)
! 3056: struct coordinate GPHUGE *points; /* the points array */
! 3057: int i; /* line segment from point i-1 to point i */
! 3058: double *ex, *ey; /* the point where it crosses an edge */
! 3059: {
! 3060: /* global x_min, x_max, y_min, x_max */
! 3061: double ax = points[i - 1].x;
! 3062: double ay = points[i - 1].y;
! 3063: double bx = points[i].x;
! 3064: double by = points[i].y;
! 3065:
! 3066: if (points[i].type == INRANGE) { /* from OUTRANGE to INRANG */
! 3067: if (inrange(ay, y_min, y_max)) {
! 3068: *ey = ay;
! 3069: if (ax > x_max)
! 3070: *ex = x_max;
! 3071: else /* x < x_min */
! 3072: *ex = x_min;
! 3073: } else {
! 3074: *ex = bx;
! 3075: if (ay > y_max)
! 3076: *ey = y_max;
! 3077: else /* y < y_min */
! 3078: *ey = y_min;
! 3079: }
! 3080: } else { /* from INRANGE to OUTRANGE */
! 3081: if (inrange(bx, x_min, x_max)) {
! 3082: *ex = bx;
! 3083: if (by > y_max)
! 3084: *ey = y_max;
! 3085: else /* y < y_min */
! 3086: *ey = y_min;
! 3087: } else {
! 3088: *ey = ay;
! 3089: if (bx > x_max)
! 3090: *ex = x_max;
! 3091: else /* x < x_min */
! 3092: *ex = x_min;
! 3093: }
! 3094: }
! 3095: return;
! 3096: }
! 3097:
! 3098: /* XXX - HOE */
! 3099: /* single edge intersection algorithm for "fsteps" curves */
! 3100: /* fsteps means step on forward y-value.
! 3101: * Given two points, one inside and one outside the plot, return
! 3102: * the point where an edge of the plot intersects the line segments
! 3103: * forming the step between the two points.
! 3104: *
! 3105: * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
! 3106: * P1 to P2 is drawn as two line segments: (x1,y1)->(x1,y2) and
! 3107: * (x1,y2)->(x2,y2).
! 3108: */
! 3109: static void edge_intersect_fsteps(points, i, ex, ey)
! 3110: struct coordinate GPHUGE *points; /* the points array */
! 3111: int i; /* line segment from point i-1 to point i */
! 3112: double *ex, *ey; /* the point where it crosses an edge */
! 3113: {
! 3114: /* global x_min, x_max, y_min, x_max */
! 3115: double ax = points[i - 1].x;
! 3116: double ay = points[i - 1].y;
! 3117: double bx = points[i].x;
! 3118: double by = points[i].y;
! 3119:
! 3120: if (points[i].type == INRANGE) { /* from OUTRANGE to INRANG */
! 3121: if (inrange(ax, x_min, x_max)) {
! 3122: *ex = ax;
! 3123: if (ay > y_max)
! 3124: *ey = y_max;
! 3125: else /* y < y_min */
! 3126: *ey = y_min;
! 3127: } else {
! 3128: *ey = by;
! 3129: if (bx > x_max)
! 3130: *ex = x_max;
! 3131: else /* x < x_min */
! 3132: *ex = x_min;
! 3133: }
! 3134: } else { /* from INRANGE to OUTRANGE */
! 3135: if (inrange(by, y_min, y_max)) {
! 3136: *ey = by;
! 3137: if (bx > x_max)
! 3138: *ex = x_max;
! 3139: else /* x < x_min */
! 3140: *ex = x_min;
! 3141: } else {
! 3142: *ex = ax;
! 3143: if (by > y_max)
! 3144: *ey = y_max;
! 3145: else /* y < y_min */
! 3146: *ey = y_min;
! 3147: }
! 3148: }
! 3149: return;
! 3150: }
! 3151:
! 3152: /* XXX - JG */
! 3153: /* double edge intersection algorithm for "steps" plot */
! 3154: /* Given two points, both outside the plot, return the points where an
! 3155: * edge of the plot intersects the line segments forming a step
! 3156: * by the two points. There may be zero, one, two, or an infinite number
! 3157: * of intersection points. (One means an intersection at a corner, infinite
! 3158: * means overlaying the edge itself). We return FALSE when there is nothing
! 3159: * to draw (zero intersections), and TRUE when there is something to
! 3160: * draw (the one-point case is a degenerate of the two-point case and we do
! 3161: * not distinguish it - we draw it anyway).
! 3162: *
! 3163: * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
! 3164: * P1 to P2 is drawn as two line segments: (x1,y1)->(x2,y1) and
! 3165: * (x2,y1)->(x2,y2).
! 3166: */
! 3167: static TBOOLEAN /* any intersection? */
! 3168: two_edge_intersect_steps(points, i, lx, ly)
! 3169: struct coordinate GPHUGE *points; /* the points array */
! 3170: int i; /* line segment from point i-1 to point i */
! 3171: double *lx, *ly; /* lx[2], ly[2]: points where it crosses edges */
! 3172: {
! 3173: /* global x_min, x_max, y_min, x_max */
! 3174: double ax = points[i - 1].x;
! 3175: double ay = points[i - 1].y;
! 3176: double bx = points[i].x;
! 3177: double by = points[i].y;
! 3178:
! 3179: if (GPMAX(ax, bx) < x_min || GPMIN(ax, bx) > x_max ||
! 3180: GPMAX(ay, by) < y_min || GPMIN(ay, by) > y_max ||
! 3181: ((ay > y_max || ay < y_min) &&
! 3182: (bx > x_max || bx < x_min))) {
! 3183: return (FALSE);
! 3184: } else if (inrange(ay, y_min, y_max) && inrange(bx, x_min, x_max)) { /* corner of step inside plotspace */
! 3185: *ly++ = ay;
! 3186: if (ax < x_min)
! 3187: *lx++ = x_min;
! 3188: else
! 3189: *lx++ = x_max;
! 3190:
! 3191: *lx++ = bx;
! 3192: if (by < y_min)
! 3193: *ly++ = y_min;
! 3194: else
! 3195: *ly++ = y_max;
! 3196:
! 3197: return (TRUE);
! 3198: } else if (inrange(ay, y_min, y_max)) { /* cross plotspace in x-direction */
! 3199: *lx++ = x_min;
! 3200: *ly++ = ay;
! 3201: *lx++ = x_max;
! 3202: *ly++ = ay;
! 3203: return (TRUE);
! 3204: } else if (inrange(ax, x_min, x_max)) { /* cross plotspace in y-direction */
! 3205: *lx++ = bx;
! 3206: *ly++ = y_min;
! 3207: *lx++ = bx;
! 3208: *ly++ = y_max;
! 3209: return (TRUE);
! 3210: } else
! 3211: return (FALSE);
! 3212: }
! 3213:
! 3214: /* XXX - HOE */
! 3215: /* double edge intersection algorithm for "fsteps" plot */
! 3216: /* Given two points, both outside the plot, return the points where an
! 3217: * edge of the plot intersects the line segments forming a step
! 3218: * by the two points. There may be zero, one, two, or an infinite number
! 3219: * of intersection points. (One means an intersection at a corner, infinite
! 3220: * means overlaying the edge itself). We return FALSE when there is nothing
! 3221: * to draw (zero intersections), and TRUE when there is something to
! 3222: * draw (the one-point case is a degenerate of the two-point case and we do
! 3223: * not distinguish it - we draw it anyway).
! 3224: *
! 3225: * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
! 3226: * P1 to P2 is drawn as two line segments: (x1,y1)->(x1,y2) and
! 3227: * (x1,y2)->(x2,y2).
! 3228: */
! 3229: static TBOOLEAN /* any intersection? */
! 3230: two_edge_intersect_fsteps(points, i, lx, ly)
! 3231: struct coordinate GPHUGE *points; /* the points array */
! 3232: int i; /* line segment from point i-1 to point i */
! 3233: double *lx, *ly; /* lx[2], ly[2]: points where it crosses edges */
! 3234: {
! 3235: /* global x_min, x_max, y_min, x_max */
! 3236: double ax = points[i - 1].x;
! 3237: double ay = points[i - 1].y;
! 3238: double bx = points[i].x;
! 3239: double by = points[i].y;
! 3240:
! 3241: if (GPMAX(ax, bx) < x_min || GPMIN(ax, bx) > x_max ||
! 3242: GPMAX(ay, by) < y_min || GPMIN(ay, by) > y_max ||
! 3243: ((by > y_max || by < y_min) &&
! 3244: (ax > x_max || ax < x_min))) {
! 3245: return (FALSE);
! 3246: } else if (inrange(by, y_min, y_max) && inrange(ax, x_min, x_max)) { /* corner of step inside plotspace */
! 3247: *lx++ = ax;
! 3248: if (ay < y_min)
! 3249: *ly++ = y_min;
! 3250: else
! 3251: *ly++ = y_max;
! 3252:
! 3253: *ly = by;
! 3254: if (bx < x_min)
! 3255: *lx = x_min;
! 3256: else
! 3257: *lx = x_max;
! 3258:
! 3259: return (TRUE);
! 3260: } else if (inrange(by, y_min, y_max)) { /* cross plotspace in x-direction */
! 3261: *lx++ = x_min;
! 3262: *ly++ = by;
! 3263: *lx = x_max;
! 3264: *ly = by;
! 3265: return (TRUE);
! 3266: } else if (inrange(ax, x_min, x_max)) { /* cross plotspace in y-direction */
! 3267: *lx++ = ax;
! 3268: *ly++ = y_min;
! 3269: *lx = ax;
! 3270: *ly = y_max;
! 3271: return (TRUE);
! 3272: } else
! 3273: return (FALSE);
! 3274: }
! 3275:
! 3276: /* double edge intersection algorithm */
! 3277: /* Given two points, both outside the plot, return
! 3278: * the points where an edge of the plot intersects the line segment defined
! 3279: * by the two points. There may be zero, one, two, or an infinite number
! 3280: * of intersection points. (One means an intersection at a corner, infinite
! 3281: * means overlaying the edge itself). We return FALSE when there is nothing
! 3282: * to draw (zero intersections), and TRUE when there is something to
! 3283: * draw (the one-point case is a degenerate of the two-point case and we do
! 3284: * not distinguish it - we draw it anyway).
! 3285: */
! 3286: static TBOOLEAN /* any intersection? */
! 3287: two_edge_intersect(points, i, lx, ly)
! 3288: struct coordinate GPHUGE *points; /* the points array */
! 3289: int i; /* line segment from point i-1 to point i */
! 3290: double *lx, *ly; /* lx[2], ly[2]: points where it crosses edges */
! 3291: {
! 3292: /* global x_min, x_max, y_min, x_max */
! 3293: int count;
! 3294: double ix = points[i - 1].x;
! 3295: double iy = points[i - 1].y;
! 3296: double ox = points[i].x;
! 3297: double oy = points[i].y;
! 3298: double t[4];
! 3299: double swap;
! 3300: double t_min, t_max;
! 3301: #if 0
! 3302: fprintf(stderr, "\ntwo_edge_intersect (%g, %g) and (%g, %g) : ",
! 3303: points[i - 1].x, points[i - 1].y,
! 3304: points[i].x, points[i].y);
! 3305: #endif
! 3306: /* nasty degenerate cases, effectively drawing to an infinity point (?)
! 3307: cope with them here, so don't process them as a "real" OUTRANGE point
! 3308:
! 3309: If more than one coord is -VERYLARGE, then can't ratio the "infinities"
! 3310: so drop out by returning FALSE */
! 3311:
! 3312: count = 0;
! 3313: if (ix == -VERYLARGE)
! 3314: count++;
! 3315: if (ox == -VERYLARGE)
! 3316: count++;
! 3317: if (iy == -VERYLARGE)
! 3318: count++;
! 3319: if (oy == -VERYLARGE)
! 3320: count++;
! 3321:
! 3322: /* either doesn't pass through graph area *or*
! 3323: can't ratio infinities to get a direction to draw line, so simply return(FALSE) */
! 3324: if (count > 1) {
! 3325: #if 0
! 3326: fprintf(stderr, "\tA\n");
! 3327: #endif
! 3328: return (FALSE);
! 3329: }
! 3330: if (ox == -VERYLARGE || ix == -VERYLARGE) {
! 3331: if (ix == -VERYLARGE) {
! 3332: /* swap points so ix/iy don't have a -VERYLARGE component */
! 3333: swap = ix;
! 3334: ix = ox;
! 3335: ox = swap;
! 3336: swap = iy;
! 3337: iy = oy;
! 3338: oy = swap;
! 3339: }
! 3340: /* check actually passes through the graph area */
! 3341: if (ix > x_max && inrange(iy, y_min, y_max)) {
! 3342: lx[0] = x_min;
! 3343: ly[0] = iy;
! 3344:
! 3345: lx[1] = x_max;
! 3346: ly[1] = iy;
! 3347: #if 0
! 3348: fprintf(stderr, "(%g %g) -> (%g %g)",
! 3349: lx[0], ly[0], lx[1], ly[1]);
! 3350: #endif
! 3351: return (TRUE);
! 3352: } else {
! 3353: #if 0
! 3354: fprintf(stderr, "\tB\n");
! 3355: #endif
! 3356: return (FALSE);
! 3357: }
! 3358: }
! 3359: if (oy == -VERYLARGE || iy == -VERYLARGE) {
! 3360: if (iy == -VERYLARGE) {
! 3361: /* swap points so ix/iy don't have a -VERYLARGE component */
! 3362: swap = ix;
! 3363: ix = ox;
! 3364: ox = swap;
! 3365: swap = iy;
! 3366: iy = oy;
! 3367: oy = swap;
! 3368: }
! 3369: /* check actually passes through the graph area */
! 3370: if (iy > y_max && inrange(ix, x_min, x_max)) {
! 3371: lx[0] = ix;
! 3372: ly[0] = y_min;
! 3373:
! 3374: lx[1] = ix;
! 3375: ly[1] = y_max;
! 3376: #if 0
! 3377: fprintf(stderr, "(%g %g) -> (%g %g)",
! 3378: lx[0], ly[0], lx[1], ly[1]);
! 3379: #endif
! 3380: return (TRUE);
! 3381: } else {
! 3382: #if 0
! 3383: fprintf(stderr, "\tC\n");
! 3384: #endif
! 3385: return (FALSE);
! 3386: }
! 3387: }
! 3388: /*
! 3389: * Special horizontal/vertical, etc. cases are checked and remaining
! 3390: * slant lines are checked separately.
! 3391: *
! 3392: * The slant line intersections are solved using the parametric form
! 3393: * of the equation for a line, since if we test x/y min/max planes explicitly
! 3394: * then e.g. a line passing through a corner point (x_min,y_min)
! 3395: * actually intersects 2 planes and hence further tests would be required
! 3396: * to anticipate this and similar situations.
! 3397: */
! 3398:
! 3399: /*
! 3400: * Can have case (ix == ox && iy == oy) as both points OUTRANGE
! 3401: */
! 3402: if (ix == ox && iy == oy) {
! 3403: /* but as only define single outrange point, can't intersect graph area */
! 3404: return (FALSE);
! 3405: }
! 3406: if (ix == ox) {
! 3407: /* line parallel to y axis */
! 3408:
! 3409: /* x coord must be in range, and line must span both y_min and y_max */
! 3410: /* note that spanning y_min implies spanning y_max, as both points OUTRANGE */
! 3411: if (!inrange(ix, x_min, x_max)) {
! 3412: return (FALSE);
! 3413: }
! 3414: if (inrange(y_min, iy, oy)) {
! 3415: lx[0] = ix;
! 3416: ly[0] = y_min;
! 3417:
! 3418: lx[1] = ix;
! 3419: ly[1] = y_max;
! 3420: #if 0
! 3421: fprintf(stderr, "(%g %g) -> (%g %g)",
! 3422: lx[0], ly[0], lx[1], ly[1]);
! 3423: #endif
! 3424: return (TRUE);
! 3425: } else
! 3426: return (FALSE);
! 3427: }
! 3428: if (iy == oy) {
! 3429: /* already checked case (ix == ox && iy == oy) */
! 3430:
! 3431: /* line parallel to x axis */
! 3432: /* y coord must be in range, and line must span both x_min and x_max */
! 3433: /* note that spanning x_min implies spanning x_max, as both points OUTRANGE */
! 3434: if (!inrange(iy, y_min, y_max)) {
! 3435: return (FALSE);
! 3436: }
! 3437: if (inrange(x_min, ix, ox)) {
! 3438: lx[0] = x_min;
! 3439: ly[0] = iy;
! 3440:
! 3441: lx[1] = x_max;
! 3442: ly[1] = iy;
! 3443: #if 0
! 3444: fprintf(stderr, "(%g %g) -> (%g %g)",
! 3445: lx[0], ly[0], lx[1], ly[1]);
! 3446: #endif
! 3447: return (TRUE);
! 3448: } else
! 3449: return (FALSE);
! 3450: }
! 3451: /* nasty 2D slanted line in an xy plane */
! 3452:
! 3453: /*
! 3454: Solve parametric equation
! 3455:
! 3456: (ix, iy) + t (diff_x, diff_y)
! 3457:
! 3458: where 0.0 <= t <= 1.0 and
! 3459:
! 3460: diff_x = (ox - ix);
! 3461: diff_y = (oy - iy);
! 3462: */
! 3463:
! 3464: t[0] = (x_min - ix) / (ox - ix);
! 3465: t[1] = (x_max - ix) / (ox - ix);
! 3466:
! 3467: if (t[0] > t[1]) {
! 3468: swap = t[0];
! 3469: t[0] = t[1];
! 3470: t[1] = swap;
! 3471: }
! 3472: t[2] = (y_min - iy) / (oy - iy);
! 3473: t[3] = (y_max - iy) / (oy - iy);
! 3474:
! 3475: if (t[2] > t[3]) {
! 3476: swap = t[2];
! 3477: t[2] = t[3];
! 3478: t[3] = swap;
! 3479: }
! 3480: t_min = GPMAX(GPMAX(t[0], t[2]), 0.0);
! 3481: t_max = GPMIN(GPMIN(t[1], t[3]), 1.0);
! 3482:
! 3483: if (t_min > t_max)
! 3484: return (FALSE);
! 3485:
! 3486: lx[0] = ix + t_min * (ox - ix);
! 3487: ly[0] = iy + t_min * (oy - iy);
! 3488:
! 3489: lx[1] = ix + t_max * (ox - ix);
! 3490: ly[1] = iy + t_max * (oy - iy);
! 3491:
! 3492: /*
! 3493: * Can only have 0 or 2 intersection points -- only need test one coord
! 3494: */
! 3495: if (inrange(lx[0], x_min, x_max) &&
! 3496: inrange(ly[0], y_min, y_max)) {
! 3497: #if 0
! 3498: fprintf(stderr, "(%g %g) -> (%g %g)",
! 3499: lx[0], ly[0], lx[1], ly[1]);
! 3500: #endif
! 3501: return (TRUE);
! 3502: }
! 3503: return (FALSE);
! 3504: }
! 3505:
! 3506: /* justify ticplace to a proper date-time value */
! 3507: double time_tic_just(level, ticplace)
! 3508: int level;
! 3509: double ticplace;
! 3510: {
! 3511: struct tm tm;
! 3512:
! 3513: if (level <= 0) {
! 3514: return (ticplace);
! 3515: }
! 3516: ggmtime(&tm, (double) ticplace);
! 3517: if (level > 0) { /* units of minutes */
! 3518: if (tm.tm_sec > 50)
! 3519: tm.tm_min++;
! 3520: tm.tm_sec = 0;
! 3521: }
! 3522: if (level > 1) { /* units of hours */
! 3523: if (tm.tm_min > 50)
! 3524: tm.tm_hour++;
! 3525: tm.tm_min = 0;
! 3526: }
! 3527: if (level > 2) { /* units of days */
! 3528: if (tm.tm_hour > 14) {
! 3529: tm.tm_hour = 0;
! 3530: tm.tm_mday = 0;
! 3531: tm.tm_yday++;
! 3532: ggmtime(&tm, (double) gtimegm(&tm));
! 3533: } else if (tm.tm_hour > 7) {
! 3534: tm.tm_hour = 12;
! 3535: } else if (tm.tm_hour > 3) {
! 3536: tm.tm_hour = 6;
! 3537: } else {
! 3538: tm.tm_hour = 0;
! 3539: }
! 3540: }
! 3541: /* skip it, I have not bothered with weekday so far */
! 3542: if (level > 4) { /* units of month */
! 3543: if (tm.tm_mday > 25) {
! 3544: tm.tm_mon++;
! 3545: if (tm.tm_mon > 11) {
! 3546: tm.tm_year++;
! 3547: tm.tm_mon = 0;
! 3548: }
! 3549: }
! 3550: tm.tm_mday = 1;
! 3551: }
! 3552: if (level > 5) {
! 3553: if (tm.tm_mon >= 7)
! 3554: tm.tm_year++;
! 3555: tm.tm_mon = 0;
! 3556: }
! 3557: ticplace = (double) gtimegm(&tm);
! 3558: ggmtime(&tm, (double) gtimegm(&tm));
! 3559: return (ticplace);
! 3560: }
! 3561:
! 3562: /* make smalltics for time-axis */
! 3563: double make_ltic(tlevel, incr)
! 3564: int tlevel;
! 3565: double incr;
! 3566: {
! 3567: double tinc;
! 3568: tinc = 0;
! 3569: if (tlevel < 0)
! 3570: tlevel = 0;
! 3571: switch (tlevel) {
! 3572: case 0:
! 3573: case 1:{
! 3574: if (incr >= 20)
! 3575: tinc = 10;
! 3576: if (incr >= 60)
! 3577: tinc = 30;
! 3578: if (incr >= 2 * 60)
! 3579: tinc = 60;
! 3580: if (incr >= 5 * 60)
! 3581: tinc = 2 * 60;
! 3582: if (incr >= 10 * 60)
! 3583: tinc = 5 * 60;
! 3584: if (incr >= 20 * 60)
! 3585: tinc = 10 * 60;
! 3586: break;
! 3587: }
! 3588: case 2:{
! 3589: if (incr >= 20 * 60)
! 3590: tinc = 10 * 60;
! 3591: if (incr >= 3600)
! 3592: tinc = 30 * 60;
! 3593: if (incr >= 2 * 3600)
! 3594: tinc = 3600;
! 3595: if (incr >= 5 * 3600)
! 3596: tinc = 2 * 3600;
! 3597: if (incr >= 10 * 3600)
! 3598: tinc = 5 * 3600;
! 3599: if (incr >= 20 * 3600)
! 3600: tinc = 10 * 3600;
! 3601: break;
! 3602: }
! 3603: case 3:{
! 3604: if (incr > 2 * 3600)
! 3605: tinc = 3600;
! 3606: if (incr > 4 * 3600)
! 3607: tinc = 2 * 3600;
! 3608: if (incr > 7 * 3600)
! 3609: tinc = 3 * 3600;
! 3610: if (incr > 13 * 3600)
! 3611: tinc = 6 * 3600;
! 3612: if (incr > DAY_SEC)
! 3613: tinc = 12 * 3600;
! 3614: if (incr > 2 * DAY_SEC)
! 3615: tinc = DAY_SEC;
! 3616: break;
! 3617: }
! 3618: case 4:{ /* week: tic per day */
! 3619: if (incr > 2 * DAY_SEC)
! 3620: tinc = DAY_SEC;
! 3621: if (incr > 7 * DAY_SEC)
! 3622: tinc = 7 * DAY_SEC;
! 3623: break;
! 3624: }
! 3625: case 5:{ /* month */
! 3626: if (incr > 2 * DAY_SEC)
! 3627: tinc = DAY_SEC;
! 3628: if (incr > 15 * DAY_SEC)
! 3629: tinc = 10 * DAY_SEC;
! 3630: if (incr > 2 * MON_SEC)
! 3631: tinc = MON_SEC;
! 3632: if (incr > 6 * MON_SEC)
! 3633: tinc = 3 * MON_SEC;
! 3634: if (incr > 2 * YEAR_SEC)
! 3635: tinc = YEAR_SEC;
! 3636: break;
! 3637: }
! 3638: case 6:{ /* year */
! 3639: if (incr > 2 * MON_SEC)
! 3640: tinc = MON_SEC;
! 3641: if (incr > 6 * MON_SEC)
! 3642: tinc = 3 * MON_SEC;
! 3643: if (incr > 2 * YEAR_SEC)
! 3644: tinc = YEAR_SEC;
! 3645: if (incr > 10 * YEAR_SEC)
! 3646: tinc = 5 * YEAR_SEC;
! 3647: if (incr > 50 * YEAR_SEC)
! 3648: tinc = 10 * YEAR_SEC;
! 3649: if (incr > 100 * YEAR_SEC)
! 3650: tinc = 20 * YEAR_SEC;
! 3651: if (incr > 200 * YEAR_SEC)
! 3652: tinc = 50 * YEAR_SEC;
! 3653: if (incr > 300 * YEAR_SEC)
! 3654: tinc = 100 * YEAR_SEC;
! 3655: break;
! 3656: }
! 3657: }
! 3658: return (tinc);
! 3659: }
! 3660:
! 3661:
! 3662: void write_multiline(x, y, text, hor, vert, angle, font)
! 3663: unsigned int x, y;
! 3664: char *text;
! 3665: enum JUSTIFY hor; /* horizontal ... */
! 3666: int vert; /* ... and vertical just - text in hor direction despite angle */
! 3667: int angle; /* assume term has already been set for this */
! 3668: char *font; /* NULL or "" means use default */
! 3669: {
! 3670: /* assumes we are free to mangle the text */
! 3671: register struct termentry *t = term;
! 3672: char *p;
! 3673: if (vert != JUST_TOP) {
! 3674: /* count lines and adjust y */
! 3675: int lines = 0; /* number of linefeeds - one fewer than lines */
! 3676: for (p = text; *p; ++p)
! 3677: if (*p == '\n')
! 3678: ++lines;
! 3679: if (angle)
! 3680: x -= (vert * lines * t->v_char) / 2;
! 3681: else
! 3682: y += (vert * lines * t->v_char) / 2;
! 3683: }
! 3684: if (font && *font)
! 3685: (*t->set_font) (font);
! 3686:
! 3687:
! 3688: for (;;) { /* we will explicitly break out */
! 3689:
! 3690: if ((p = strchr(text, '\n')) != NULL)
! 3691: *p = 0; /* terminate the string */
! 3692:
! 3693: if ((*t->justify_text) (hor)) {
! 3694: (*t->put_text) (x, y, text);
! 3695: } else {
! 3696: int fix = hor * (t->h_char) * strlen(text) / 2;
! 3697: if (angle)
! 3698: (*t->put_text) (x, y - fix, text);
! 3699: else
! 3700: (*t->put_text) (x - fix, y, text);
! 3701: }
! 3702: if (angle)
! 3703: x += t->v_char;
! 3704: else
! 3705: y -= t->v_char;
! 3706:
! 3707: if (!p)
! 3708: break;
! 3709:
! 3710: text = p + 1;
! 3711: } /* unconditional branch back to the for(;;) - just a goto ! */
! 3712:
! 3713: if (font && *font)
! 3714: (*t->set_font) (default_font);
! 3715: }
! 3716:
! 3717: /* display a x-axis ticmark - called by gen_ticks */
! 3718: /* also uses global tic_start, tic_direction, tic_text and tic_just */
! 3719: static void xtick2d_callback(axis, place, text, grid)
! 3720: int axis;
! 3721: double place;
! 3722: char *text;
! 3723: struct lp_style_type grid; /* linetype or -2 for no grid */
! 3724: {
! 3725: register struct termentry *t = term;
! 3726: /* minitick if text is NULL - beware - h_tic is unsigned */
! 3727: int ticsize = tic_direction * (int) (t->v_tic) * (text ? ticscale : miniticscale);
! 3728: unsigned int x = map_x(place);
! 3729:
! 3730: if (grid.l_type > -2) {
! 3731: term_apply_lp_properties(&grid);
! 3732: if (polar_grid_angle) {
! 3733: double x = place, y = 0, s = sin(0.1), c = cos(0.1);
! 3734: int i;
! 3735: int ogx = map_x(x);
! 3736: int ogy = map_y(0);
! 3737: int tmpgx, tmpgy, gx, gy;
! 3738:
! 3739: if (place > largest_polar_circle)
! 3740: largest_polar_circle = place;
! 3741: else if (-place > largest_polar_circle)
! 3742: largest_polar_circle = -place;
! 3743: for (i = 1; i <= 63 /* 2pi/0.1 */ ; ++i) {
! 3744: {
! 3745: /* cos(t+dt) = cos(t)cos(dt)-sin(t)cos(dt) */
! 3746: double tx = x * c - y * s;
! 3747: /* sin(t+dt) = sin(t)cos(dt)+cos(t)sin(dt) */
! 3748: y = y * c + x * s;
! 3749: x = tx;
! 3750: }
! 3751: tmpgx = gx = map_x(x);
! 3752: tmpgy = gy = map_y(y);
! 3753: if (clip_line(&ogx, &ogy, &tmpgx, &tmpgy)) {
! 3754: (*t->move) ((unsigned int) ogx, (unsigned int) ogy);
! 3755: (*t->vector) ((unsigned int) tmpgx, (unsigned int) tmpgy);
! 3756: }
! 3757: ogx = gx;
! 3758: ogy = gy;
! 3759: }
! 3760: } else {
! 3761: if (lkey && key_yt > ybot && x < key_xr && x > key_xl) {
! 3762: if (key_yb > ybot) {
! 3763: (*t->move) (x, ybot);
! 3764: (*t->vector) (x, key_yb);
! 3765: }
! 3766: if (key_yt < ytop) {
! 3767: (*t->move) (x, key_yt);
! 3768: (*t->vector) (x, ytop);
! 3769: }
! 3770: } else {
! 3771: (*t->move) (x, ybot);
! 3772: (*t->vector) (x, ytop);
! 3773: }
! 3774: }
! 3775: term_apply_lp_properties(&border_lp); /* border linetype */
! 3776: }
! 3777: /* we precomputed tic posn and text posn in global vars */
! 3778:
! 3779: (*t->move) (x, tic_start);
! 3780: (*t->vector) (x, tic_start + ticsize);
! 3781:
! 3782: if (tic_mirror >= 0) {
! 3783: (*t->move) (x, tic_mirror);
! 3784: (*t->vector) (x, tic_mirror - ticsize);
! 3785: }
! 3786: if (text)
! 3787: write_multiline(x, tic_text, text, tic_hjust, tic_vjust, rotate_tics, NULL);
! 3788: }
! 3789:
! 3790: /* display a y-axis ticmark - called by gen_ticks */
! 3791: /* also uses global tic_start, tic_direction, tic_text and tic_just */
! 3792: static void ytick2d_callback(axis, place, text, grid)
! 3793: int axis;
! 3794: double place;
! 3795: char *text;
! 3796: struct lp_style_type grid; /* linetype or -2 */
! 3797: {
! 3798: register struct termentry *t = term;
! 3799: /* minitick if text is NULL - v_tic is unsigned */
! 3800: int ticsize = tic_direction * (int) (t->h_tic) * (text ? ticscale : miniticscale);
! 3801: unsigned int y = map_y(place);
! 3802: if (grid.l_type > -2) {
! 3803: term_apply_lp_properties(&grid);
! 3804: if (polar_grid_angle) {
! 3805: double x = 0, y = place, s = sin(0.1), c = cos(0.1);
! 3806: int i;
! 3807: if (place > largest_polar_circle)
! 3808: largest_polar_circle = place;
! 3809: else if (-place > largest_polar_circle)
! 3810: largest_polar_circle = -place;
! 3811: clip_move(map_x(x), map_y(y));
! 3812: for (i = 1; i <= 63 /* 2pi/0.1 */ ; ++i) {
! 3813: {
! 3814: /* cos(t+dt) = cos(t)cos(dt)-sin(t)cos(dt) */
! 3815: double tx = x * c - y * s;
! 3816: /* sin(t+dt) = sin(t)cos(dt)+cos(t)sin(dt) */
! 3817: y = y * c + x * s;
! 3818: x = tx;
! 3819: }
! 3820: clip_vector(map_x(x), map_y(y));
! 3821: }
! 3822: } else {
! 3823: if (lkey && y < key_yt && y > key_yb && key_xl < xright /* catch TOUT */ ) {
! 3824: if (key_xl > xleft) {
! 3825: (*t->move) (xleft, y);
! 3826: (*t->vector) (key_xl, y);
! 3827: }
! 3828: if (key_xr < xright) {
! 3829: (*t->move) (key_xr, y);
! 3830: (*t->vector) (xright, y);
! 3831: }
! 3832: } else {
! 3833: (*t->move) (xleft, y);
! 3834: (*t->vector) (xright, y);
! 3835: }
! 3836: }
! 3837: term_apply_lp_properties(&border_lp); /* border linetype */
! 3838: }
! 3839: /* we precomputed tic posn and text posn */
! 3840:
! 3841: (*t->move) (tic_start, y);
! 3842: (*t->vector) (tic_start + ticsize, y);
! 3843:
! 3844: if (tic_mirror >= 0) {
! 3845: (*t->move) (tic_mirror, y);
! 3846: (*t->vector) (tic_mirror - ticsize, y);
! 3847: }
! 3848: if (text)
! 3849: write_multiline(tic_text, y, text, tic_hjust, tic_vjust, rotate_tics, NULL);
! 3850: }
! 3851:
! 3852: int label_width(str, lines)
! 3853: char *str;
! 3854: int *lines;
! 3855: {
! 3856: char lab[MAX_LINE_LEN + 1], *s, *e;
! 3857: int mlen, len, l;
! 3858:
! 3859: l = mlen = len = 0;
! 3860: sprintf(lab, "%s\n", str);
! 3861: s = lab;
! 3862: while ((e = (char *) strchr(s, '\n')) != NULL) { /* HBB 980308: quiet BC-3.1 warning */
! 3863: *e = '\0';
! 3864: len = strlen(s); /* = e-s ? */
! 3865: if (len > mlen)
! 3866: mlen = len;
! 3867: if (len || l)
! 3868: l++;
! 3869: s = ++e;
! 3870: }
! 3871: /* lines = NULL => not interested - div */
! 3872: if (lines)
! 3873: *lines = l;
! 3874: return (mlen);
! 3875: }
! 3876:
! 3877:
! 3878: void setup_tics(axis, ticdef, format, max)
! 3879: int axis;
! 3880: struct ticdef *ticdef;
! 3881: char *format;
! 3882: int max; /* approx max number of slots available */
! 3883: {
! 3884: double tic = 0; /* HBB: shut up gcc -Wall */
! 3885:
! 3886: int fixmin = (auto_array[axis] & 1) != 0;
! 3887: int fixmax = (auto_array[axis] & 2) != 0;
! 3888:
! 3889: if (ticdef->type == TIC_SERIES) {
! 3890: ticstep[axis] = tic = ticdef->def.series.incr;
! 3891: fixmin &= (ticdef->def.series.start == -VERYLARGE);
! 3892: fixmax &= (ticdef->def.series.end == VERYLARGE);
! 3893: } else if (ticdef->type == TIC_COMPUTED) {
! 3894: ticstep[axis] = tic = make_tics(axis, max);
! 3895: } else {
! 3896: fixmin = fixmax = 0; /* user-defined, day or month */
! 3897: }
! 3898:
! 3899: if (fixmin) {
! 3900: if (min_array[axis] < max_array[axis])
! 3901: min_array[axis] = tic * floor(min_array[axis] / tic);
! 3902: else
! 3903: min_array[axis] = tic * ceil(min_array[axis] / tic);
! 3904: }
! 3905: if (fixmax) {
! 3906: if (min_array[axis] < max_array[axis])
! 3907: max_array[axis] = tic * ceil(max_array[axis] / tic);
! 3908: else
! 3909: max_array[axis] = tic * floor(max_array[axis] / tic);
! 3910: }
! 3911: if (datatype[axis] == TIME && format_is_numeric[axis])
! 3912: /* invent one for them */
! 3913: timetic_format(axis, min_array[axis], max_array[axis]);
! 3914: else
! 3915: strcpy(ticfmt[axis], format);
! 3916: }
! 3917:
! 3918: /*{{{ mant_exp - split into mantissa and/or exponent */
! 3919: static void mant_exp(log_base, x, scientific, m, p)
! 3920: double log_base, x;
! 3921: int scientific; /* round to power of 3 */
! 3922: double *m;
! 3923: int *p; /* results */
! 3924: {
! 3925: int sign = 1;
! 3926: double l10;
! 3927: int power;
! 3928: /*{{{ check 0 */
! 3929: if (x == 0) {
! 3930: if (m)
! 3931: *m = 0;
! 3932: if (p)
! 3933: *p = 0;
! 3934: return;
! 3935: }
! 3936: /*}}} */
! 3937: /*{{{ check -ve */
! 3938: if (x < 0) {
! 3939: sign = (-1);
! 3940: x = (-x);
! 3941: }
! 3942: /*}}} */
! 3943:
! 3944: l10 = log10(x) / log_base;
! 3945: power = floor(l10);
! 3946: if (scientific) {
! 3947: power = 3 * floor(power / 3.0);
! 3948: }
! 3949: if (m)
! 3950: *m = sign * pow(10.0, (l10 - power) * log_base);
! 3951: if (p)
! 3952: *p = power;
! 3953: }
! 3954: /*}}} */
! 3955:
! 3956: /*
! 3957: * Kludge alert!!
! 3958: * Workaround until we have a better solution ...
! 3959: * Note: this assumes that all calls to sprintf in gprintf have
! 3960: * exactly three args. Lars
! 3961: */
! 3962: #ifdef HAVE_SNPRINTF
! 3963: # define sprintf(str,fmt,arg) \
! 3964: if (snprintf((str),count,(fmt),(arg)) > count) \
! 3965: fprintf (stderr,"%s:%d: Warning: too many digits for format\n",__FILE__,__LINE__)
! 3966: #endif
! 3967:
! 3968: /*{{{ gprintf */
! 3969: /* extended snprintf */
! 3970: static void gprintf(dest, count, format, log_base, x)
! 3971: char *dest, *format;
! 3972: size_t count;
! 3973: double log_base, x; /* we print one number in a number of different formats */
! 3974: {
! 3975: #define LOC_PI 3.14159265358979323846 /* local definition of PI */
! 3976: char temp[MAX_LINE_LEN];
! 3977: char *t;
! 3978:
! 3979: for (;;) {
! 3980: /*{{{ copy to dest until % */
! 3981: while (*format != '%')
! 3982: if (!(*dest++ = *format++))
! 3983: return; /* end of format */
! 3984: /*}}} */
! 3985:
! 3986: /*{{{ check for %% */
! 3987: if (format[1] == '%') {
! 3988: *dest++ = '%';
! 3989: format += 2;
! 3990: continue;
! 3991: }
! 3992: /*}}} */
! 3993:
! 3994: /*{{{ copy format part to temp, excluding conversion character */
! 3995: t = temp;
! 3996: *t++ = '%';
! 3997: /* dont put isdigit first since sideeffect in macro is bad */
! 3998: while (*++format == '.' || isdigit((int) *format) ||
! 3999: *format == '-' || *format == '+' || *format == ' ')
! 4000: *t++ = *format;
! 4001: /*}}} */
! 4002:
! 4003: /*{{{ convert conversion character */
! 4004: switch (*format) {
! 4005: /*{{{ x and o */
! 4006: case 'x':
! 4007: case 'X':
! 4008: case 'o':
! 4009: case 'O':
! 4010: t[0] = *format++;
! 4011: t[1] = 0;
! 4012: sprintf(dest, temp, (int) x);
! 4013: dest += strlen(dest);
! 4014: break;
! 4015: /*}}} */
! 4016: /*{{{ e, f and g */
! 4017: case 'e':
! 4018: case 'E':
! 4019: case 'f':
! 4020: case 'F':
! 4021: case 'g':
! 4022: case 'G':
! 4023: t[0] = *format++;
! 4024: t[1] = 0;
! 4025: sprintf(dest, temp, x);
! 4026: dest += strlen(dest);
! 4027: break;
! 4028: /*}}} */
! 4029: /*{{{ l */
! 4030: case 'l':
! 4031: {
! 4032: double mantissa;
! 4033: mant_exp(log_base, x, 0, &mantissa, NULL);
! 4034: t[0] = 'f';
! 4035: t[1] = 0;
! 4036: sprintf(dest, temp, mantissa);
! 4037: dest += strlen(dest);
! 4038: ++format;
! 4039: break;
! 4040: }
! 4041: /*}}} */
! 4042: /*{{{ t */
! 4043: case 't':
! 4044: {
! 4045: double mantissa;
! 4046: mant_exp(1.0, x, 0, &mantissa, NULL);
! 4047: t[0] = 'f';
! 4048: t[1] = 0;
! 4049: sprintf(dest, temp, mantissa);
! 4050: dest += strlen(dest);
! 4051: ++format;
! 4052: break;
! 4053: }
! 4054: /*}}} */
! 4055: /*{{{ s */
! 4056: case 's':
! 4057: {
! 4058: double mantissa;
! 4059: mant_exp(1.0, x, 1, &mantissa, NULL);
! 4060: t[0] = 'f';
! 4061: t[1] = 0;
! 4062: sprintf(dest, temp, mantissa);
! 4063: dest += strlen(dest);
! 4064: ++format;
! 4065: break;
! 4066: }
! 4067: /*}}} */
! 4068: /*{{{ L */
! 4069: case 'L':
! 4070: {
! 4071: int power;
! 4072: mant_exp(log_base, x, 0, NULL, &power);
! 4073: t[0] = 'd';
! 4074: t[1] = 0;
! 4075: sprintf(dest, temp, power);
! 4076: dest += strlen(dest);
! 4077: ++format;
! 4078: break;
! 4079: }
! 4080: /*}}} */
! 4081: /*{{{ T */
! 4082: case 'T':
! 4083: {
! 4084: int power;
! 4085: mant_exp(1.0, x, 0, NULL, &power);
! 4086: t[0] = 'd';
! 4087: t[1] = 0;
! 4088: sprintf(dest, temp, power);
! 4089: dest += strlen(dest);
! 4090: ++format;
! 4091: break;
! 4092: }
! 4093: /*}}} */
! 4094: /*{{{ S */
! 4095: case 'S':
! 4096: {
! 4097: int power;
! 4098: mant_exp(1.0, x, 1, NULL, &power);
! 4099: t[0] = 'd';
! 4100: t[1] = 0;
! 4101: sprintf(dest, temp, power);
! 4102: dest += strlen(dest);
! 4103: ++format;
! 4104: break;
! 4105: }
! 4106: /*}}} */
! 4107: /*{{{ c */
! 4108: case 'c':
! 4109: {
! 4110: int power;
! 4111: mant_exp(1.0, x, 1, NULL, &power);
! 4112: t[0] = 'c';
! 4113: t[1] = 0;
! 4114: power = power / 3 + 6; /* -18 -> 0, 0 -> 6, +18 -> 12, ... */
! 4115: if (power >= 0 && power <= 12) {
! 4116: sprintf(dest, temp, "afpnum kMGTPE"[power]);
! 4117: } else {
! 4118: /* please extend the range ! */
! 4119: /* name power name power
! 4120: -------------------------
! 4121: atto -18 Exa 18
! 4122: femto -15 Peta 15
! 4123: pico -12 Tera 12
! 4124: nano -9 Giga 9
! 4125: micro -6 Mega 6
! 4126: milli -3 kilo 3 */
! 4127:
! 4128: /* for the moment, print e+21 for example */
! 4129: sprintf(dest, "e%+02d", (power - 6) * 3);
! 4130: }
! 4131:
! 4132: dest += strlen(dest);
! 4133: ++format;
! 4134: break;
! 4135: }
! 4136: case 'P':
! 4137: {
! 4138: t[0] = 'f';
! 4139: t[1] = 0;
! 4140: sprintf(dest, temp, x / LOC_PI);
! 4141: dest += strlen(dest);
! 4142: ++format;
! 4143: break;
! 4144: }
! 4145: /*}}} */
! 4146: default:
! 4147: int_error("Bad format character", NO_CARET);
! 4148: }
! 4149: /*}}} */
! 4150: }
! 4151: }
! 4152: #undef LOC_PI /* local definition of PI */
! 4153: /*}}} */
! 4154: #ifdef HAVE_SNPRINTF
! 4155: # undef sprintf
! 4156: #endif
! 4157:
! 4158:
! 4159:
! 4160: /*{{{ gen_tics */
! 4161: /* uses global arrays ticstep[], ticfmt[], min_array[], max_array[],
! 4162: * auto_array[], log_array[], log_base_array[]
! 4163: * we use any of GRID_X/Y/X2/Y2 and _MX/_MX2/etc - caller is expected
! 4164: * to clear the irrelevent fields from global grid bitmask
! 4165: * note this is also called from graph3d, so we need GRID_Z too
! 4166: */
! 4167:
! 4168: void gen_tics(axis, def, grid, minitics, minifreq, callback)
! 4169: int axis; /* FIRST_X_AXIS, etc */
! 4170: struct ticdef *def; /* tic defn */
! 4171: int grid; /* GRID_X | GRID_MX etc */
! 4172: int minitics; /* minitics - off/default/auto/explicit */
! 4173: double minifreq; /* frequency */
! 4174: tic_callback callback; /* fn to call to actually do the work */
! 4175: {
! 4176: /* seperate main-tic part of grid */
! 4177: struct lp_style_type lgrd, mgrd;
! 4178:
! 4179: memcpy(&lgrd, &grid_lp, sizeof(struct lp_style_type));
! 4180: memcpy(&mgrd, &mgrid_lp, sizeof(struct lp_style_type));
! 4181: lgrd.l_type = (grid & (GRID_X | GRID_Y | GRID_X2 | GRID_Y2 | GRID_Z)) ? grid_lp.l_type : -2;
! 4182: mgrd.l_type = (grid & (GRID_MX | GRID_MY | GRID_MX2 | GRID_MY2 | GRID_MZ)) ? mgrid_lp.l_type : -2;
! 4183:
! 4184: if (def->type == TIC_USER) { /* special case */
! 4185: /*{{{ do user tics then return */
! 4186: struct ticmark *mark = def->def.user;
! 4187: double uncertain = (max_array[axis] - min_array[axis]) / 10;
! 4188: double ticmin = min_array[axis] - SIGNIF * uncertain;
! 4189: double internal_max = max_array[axis] + SIGNIF * uncertain;
! 4190: double log_base = log_array[axis] ? log10(base_array[axis]) : 1.0;
! 4191:
! 4192: /* polar labels always +ve, and if rmin has been set, they are
! 4193: * relative to rmin. position is as user specified, but must
! 4194: * be translated. I dont think it will work at all for
! 4195: * log scale, so I shan't worry about it !
! 4196: */
! 4197: double polar_shift = (polar && !(autoscale_r & 1)) ? rmin : 0;
! 4198:
! 4199: for (mark = def->def.user; mark; mark = mark->next) {
! 4200: char label[64];
! 4201: double internal = log_array[axis] ? log(mark->position) / log_base_array[axis] : mark->position;
! 4202:
! 4203: internal -= polar_shift;
! 4204:
! 4205: if (!inrange(internal, ticmin, internal_max))
! 4206: continue;
! 4207:
! 4208: if (datatype[axis] == TIME)
! 4209: gstrftime(label, 24, mark->label ? mark->label : ticfmt[axis], mark->position);
! 4210: else
! 4211: gprintf(label, sizeof(label), mark->label ? mark->label : ticfmt[axis], log_base, mark->position);
! 4212:
! 4213: (*callback) (axis, internal, label, lgrd);
! 4214: }
! 4215:
! 4216: return; /* NO MINITICS FOR USER-DEF TICS */
! 4217: /*}}} */
! 4218: }
! 4219: /* series-tics
! 4220: * need to distinguish user co-ords from internal co-ords.
! 4221: * - for logscale, internal = log(user), else internal = user
! 4222: *
! 4223: * The minitics are a bit of a drag - we need to distinuish
! 4224: * the cases step>1 from step == 1.
! 4225: * If step = 1, we are looking at 1,10,100,1000 for example, so
! 4226: * minitics are 2,5,8, ... - done in user co-ordinates
! 4227: * If step>1, we are looking at 1,1e6,1e12 for example, so
! 4228: * minitics are 10,100,1000,... - done in internal co-ords
! 4229: */
! 4230:
! 4231: {
! 4232: double tic; /* loop counter */
! 4233: double internal; /* in internal co-ords */
! 4234: double user; /* in user co-ords */
! 4235: double start, step, end;
! 4236: double lmin = min_array[axis], lmax = max_array[axis];
! 4237: double internal_min, internal_max; /* to allow for rounding errors */
! 4238: double ministart = 0, ministep = 1, miniend = 1; /* internal or user - depends on step */
! 4239: int anyticput = 0; /* for detection of infinite loop */
! 4240:
! 4241: /* gprintf uses log10() of base - log_base_array is log() */
! 4242: double log_base = log_array[axis] ? log10(base_array[axis]) : 1.0;
! 4243:
! 4244: if (lmax < lmin) {
! 4245: /* hmm - they have set reversed range for some reason */
! 4246: double temp = lmin;
! 4247: lmin = lmax;
! 4248: lmax = temp;
! 4249: }
! 4250: /*{{{ choose start, step and end */
! 4251: switch (def->type) {
! 4252: case TIC_SERIES:
! 4253: if (log_array[axis]) {
! 4254: /* we can tolerate start <= 0 if step and end > 0 */
! 4255: if (def->def.series.end <= 0 ||
! 4256: def->def.series.incr <= 0)
! 4257: return; /* just quietly ignore */
! 4258: step = log(def->def.series.incr) / log_base_array[axis];
! 4259: end = log(def->def.series.end) / log_base_array[axis];
! 4260: start = def->def.series.start > 0 ?
! 4261: log(def->def.series.start) / log_base_array[axis] :
! 4262: step;
! 4263: } else {
! 4264: start = def->def.series.start;
! 4265: step = def->def.series.incr;
! 4266: end = def->def.series.end;
! 4267: if (start == -VERYLARGE)
! 4268: start = step * floor(lmin / step);
! 4269: if (end == VERYLARGE)
! 4270: end = step * ceil(lmax / step);
! 4271: }
! 4272: break;
! 4273: case TIC_COMPUTED:
! 4274: /* round to multiple of step */
! 4275: start = ticstep[axis] * floor(lmin / ticstep[axis]);
! 4276: step = ticstep[axis];
! 4277: end = ticstep[axis] * ceil(lmax / ticstep[axis]);
! 4278: break;
! 4279: case TIC_MONTH:
! 4280: start = floor(lmin);
! 4281: end = ceil(lmax);
! 4282: step = floor((end - start) / 12);
! 4283: if (step < 1)
! 4284: step = 1;
! 4285: break;
! 4286: case TIC_DAY:
! 4287: start = floor(lmin);
! 4288: end = ceil(lmax);
! 4289: step = floor((end - start) / 14);
! 4290: if (step < 1)
! 4291: step = 1;
! 4292: break;
! 4293: default:
! 4294: graph_error("Internal error : unknown tic type");
! 4295: return; /* avoid gcc -Wall warning about start */
! 4296: }
! 4297: /*}}} */
! 4298:
! 4299: /*{{{ ensure ascending order */
! 4300: if (end < start) {
! 4301: double temp;
! 4302: temp = end;
! 4303: end = start;
! 4304: start = temp;
! 4305: }
! 4306: step = fabs(step);
! 4307: /*}}} */
! 4308:
! 4309: if (minitics) {
! 4310: /*{{{ figure out ministart, ministep, miniend */
! 4311: if (minitics == MINI_USER) {
! 4312: /* they have said what they want */
! 4313: if (minifreq <= 0)
! 4314: minitics = 0; /* not much else we can do */
! 4315: else if (log_array[axis]) {
! 4316: ministart = ministep = step / minifreq * base_array[axis];
! 4317: miniend = step * base_array[axis];
! 4318: } else {
! 4319: ministart = ministep = step / minifreq;
! 4320: miniend = step;
! 4321: }
! 4322: } else if (log_array[axis]) {
! 4323: if (step > 1.5) { /* beware rounding errors */
! 4324: /*{{{ 10,100,1000 case */
! 4325: /* no more than five minitics */
! 4326: ministart = ministep = (int) (0.2 * step);
! 4327: if (ministep < 1)
! 4328: ministart = ministep = 1;
! 4329: miniend = step;
! 4330: /*}}} */
! 4331: } else {
! 4332: /*{{{ 2,5,8 case */
! 4333: miniend = base_array[axis];
! 4334: if (end - start >= 10)
! 4335: minitics = 0; /* none */
! 4336: else if (end - start >= 5) {
! 4337: ministart = 2;
! 4338: ministep = 3;
! 4339: } else {
! 4340: ministart = 2;
! 4341: ministep = 1;
! 4342: }
! 4343: /*}}} */
! 4344: }
! 4345: } else if (datatype[axis] == TIME) {
! 4346: ministart = ministep = make_ltic(timelevel[axis], step);
! 4347: miniend = step * 0.9;
! 4348: } else if (minitics == MINI_AUTO) {
! 4349: ministart = ministep = 0.1 * step;
! 4350: miniend = step;
! 4351: } else
! 4352: minitics = 0;
! 4353:
! 4354: if (ministep <= 0)
! 4355: minitics = 0; /* dont get stuck in infinite loop */
! 4356: /*}}} */
! 4357: }
! 4358: /*{{{ a few tweaks and checks */
! 4359: /* watch rounding errors */
! 4360: end += SIGNIF * step;
! 4361: internal_max = lmax + step * SIGNIF;
! 4362: internal_min = lmin - step * SIGNIF;
! 4363:
! 4364: if (step == 0)
! 4365: return; /* just quietly ignore them ! */
! 4366: /*}}} */
! 4367:
! 4368: for (tic = start; tic <= end; tic += step) {
! 4369: if (anyticput == 2) /* See below... */
! 4370: break;
! 4371: if (anyticput && (fabs(tic - start) < DBL_EPSILON)) {
! 4372: /* step is too small.. */
! 4373: anyticput = 2; /* Don't try again. */
! 4374: tic = end; /* Put end tic. */
! 4375: } else
! 4376: anyticput = 1;
! 4377:
! 4378: /*{{{ calc internal and user co-ords */
! 4379: if (!log_array[axis]) {
! 4380: internal = datatype[axis] == TIME ? time_tic_just(timelevel[axis], tic) : tic;
! 4381: user = CheckZero(internal, step);
! 4382: } else {
! 4383: /* log scale => dont need to worry about zero ? */
! 4384: internal = tic;
! 4385: user = pow(base_array[axis], internal);
! 4386: }
! 4387: /*}}} */
! 4388: if (internal > internal_max)
! 4389: break; /* gone too far - end of series = VERYLARGE perhaps */
! 4390: if (internal >= internal_min) {
! 4391: /* continue; *//* maybe minitics!!!. user series starts below min ? */
! 4392:
! 4393: /*{{{ draw tick via callback */
! 4394: switch (def->type) {
! 4395: case TIC_DAY:{
! 4396: int d = (long) floor(user + 0.5) % 7;
! 4397: if (d < 0)
! 4398: d += 7;
! 4399: (*callback) (axis, internal, abbrev_day_names[d], lgrd);
! 4400: break;
! 4401: }
! 4402: case TIC_MONTH:{
! 4403: int m = (long) floor(user - 1) % 12;
! 4404: if (m < 0)
! 4405: m += 12;
! 4406: (*callback) (axis, internal, abbrev_month_names[m], lgrd);
! 4407: break;
! 4408: }
! 4409: default:{ /* comp or series */
! 4410: char label[64];
! 4411: if (datatype[axis] == TIME) {
! 4412: /* If they are doing polar time plot, good luck to them */
! 4413: gstrftime(label, 24, ticfmt[axis], (double) user);
! 4414: } else if (polar) {
! 4415: /* if rmin is set, we stored internally with r-rmin */
! 4416: #if 0 /* Igor's polar-grid patch */
! 4417: double r = fabs(user) + (autoscale_r & 1 ? 0 : rmin);
! 4418: #else
! 4419: /* Igor removed fabs to allow -ve labels */
! 4420: double r = user + (autoscale_r & 1 ? 0 : rmin);
! 4421: #endif
! 4422: gprintf(label, sizeof(label), ticfmt[axis], log_base, r);
! 4423: } else {
! 4424: gprintf(label, sizeof(label), ticfmt[axis], log_base, user);
! 4425: }
! 4426: (*callback) (axis, internal, label, lgrd);
! 4427: }
! 4428: }
! 4429: /*}}} */
! 4430:
! 4431: }
! 4432: if (minitics) {
! 4433: /*{{{ process minitics */
! 4434: double mplace, mtic;
! 4435: for (mplace = ministart; mplace < miniend; mplace += ministep) {
! 4436: if (datatype[axis] == TIME)
! 4437: mtic = time_tic_just(timelevel[axis] - 1, internal + mplace);
! 4438: else
! 4439: mtic = internal + (log_array[axis] && step <= 1.5 ? log(mplace) / log_base_array[axis] : mplace);
! 4440: if (inrange(mtic, internal_min, internal_max) &&
! 4441: inrange(mtic, start - step * SIGNIF, end + step * SIGNIF))
! 4442: (*callback) (axis, mtic, NULL, mgrd);
! 4443: }
! 4444: /*}}} */
! 4445: }
! 4446: }
! 4447: }
! 4448: }
! 4449: /*}}} */
! 4450:
! 4451: /*{{{ map_position */
! 4452: static void map_position(pos, x, y, what)
! 4453: struct position *pos;
! 4454: unsigned int *x, *y;
! 4455: char *what;
! 4456: {
! 4457: switch (pos->scalex) {
! 4458: case first_axes:
! 4459: {
! 4460: double xx = LogScale(pos->x, log_array[FIRST_X_AXIS], log_base_array[FIRST_X_AXIS], what, "x");
! 4461: *x = xleft + (xx - min_array[FIRST_X_AXIS]) * scale[FIRST_X_AXIS] + 0.5;
! 4462: break;
! 4463: }
! 4464: case second_axes:
! 4465: {
! 4466: double xx = LogScale(pos->x, log_array[SECOND_X_AXIS], log_base_array[SECOND_X_AXIS], what, "x");
! 4467: *x = xleft + (xx - min_array[SECOND_X_AXIS]) * scale[SECOND_X_AXIS] + 0.5;
! 4468: break;
! 4469: }
! 4470: case graph:
! 4471: {
! 4472: *x = xleft + pos->x * (xright - xleft) + 0.5;
! 4473: break;
! 4474: }
! 4475: case screen:
! 4476: {
! 4477: register struct termentry *t = term;
! 4478: *x = pos->x * (t->xmax) + 0.5;
! 4479: break;
! 4480: }
! 4481: }
! 4482: switch (pos->scaley) {
! 4483: case first_axes:
! 4484: {
! 4485: double yy = LogScale(pos->y, log_array[FIRST_Y_AXIS], log_base_array[FIRST_Y_AXIS], what, "y");
! 4486: *y = ybot + (yy - min_array[FIRST_Y_AXIS]) * scale[FIRST_Y_AXIS] + 0.5;
! 4487: return;
! 4488: }
! 4489: case second_axes:
! 4490: {
! 4491: double yy = LogScale(pos->y, log_array[SECOND_Y_AXIS], log_base_array[SECOND_Y_AXIS], what, "y");
! 4492: *y = ybot + (yy - min_array[SECOND_Y_AXIS]) * scale[SECOND_Y_AXIS] + 0.5;
! 4493: return;
! 4494: }
! 4495: case graph:
! 4496: {
! 4497: *y = ybot + pos->y * (ytop - ybot) + 0.5;
! 4498: return;
! 4499: }
! 4500: case screen:
! 4501: {
! 4502: register struct termentry *t = term;
! 4503: *y = pos->y * (t->ymax) + 0.5;
! 4504: return;
! 4505: }
! 4506: }
! 4507: }
! 4508: /*}}} */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to graphics.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot