Annotation of OpenXM_contrib/gnuplot/term/latex.trm, Revision 1.1
1.1 ! maekawa 1: /*
! 2: * $Id: latex.trm,v 1.63 1998/04/14 00:17:53 drd Exp $
! 3: *
! 4: */
! 5:
! 6: /* GNUPLOT - latex.trm */
! 7:
! 8: /*[
! 9: * Copyright 1990 - 1993, 1998
! 10: *
! 11: * Permission to use, copy, and distribute this software and its
! 12: * documentation for any purpose with or without fee is hereby granted,
! 13: * provided that the above copyright notice appear in all copies and
! 14: * that both that copyright notice and this permission notice appear
! 15: * in supporting documentation.
! 16: *
! 17: * Permission to modify the software is granted, but not the right to
! 18: * distribute the complete modified source code. Modifications are to
! 19: * be distributed as patches to the released version. Permission to
! 20: * distribute binaries produced by compiling modified sources is granted,
! 21: * provided you
! 22: * 1. distribute the corresponding source modifications from the
! 23: * released version in the form of a patch file along with the binaries,
! 24: * 2. add special version identification to distinguish your version
! 25: * in addition to the base release version number,
! 26: * 3. provide your name and address as the primary contact for the
! 27: * support of your modified version, and
! 28: * 4. retain our contact information in regard to use of the base
! 29: * software.
! 30: * Permission to distribute the released version of the source code along
! 31: * with corresponding source modifications in the form of a patch file is
! 32: * granted with same provisions 2 through 4 for binary distributions.
! 33: *
! 34: * This software is provided "as is" without express or implied warranty
! 35: * to the extent permitted by applicable law.
! 36: ]*/
! 37:
! 38: /*
! 39: * This file is included by ../term.c.
! 40: *
! 41: * This terminal driver supports:
! 42: * LaTeX pictures (latex).
! 43: * LaTeX pictures with emTeX specials (emtex).
! 44: *
! 45: * AUTHORS
! 46: * David Kotz, Russell Lang
! 47: *
! 48: * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
! 49: *
! 50: */
! 51:
! 52: /* modified to optimize use of \rule for long lines */
! 53: /* TLDC: modified to have nice line types */
! 54:
! 55: /* the following LATEX driver has been modified by
! 56: Russell Lang, eln272v@monu1.cc.monash.oz from the
! 57: GnuTeX 1.3 driver by David Kotz, David.Kotz@Dartmouth.edu.
! 58: Since then it has been further extended by David Kotz.
! 59: EmTeX driver by Russell Lang. */
! 60:
! 61: /* 9 Dec 1992 LATEX_put_text rewritten to handle \\ newlines
! 62: Daniel S. Lewart (d-lewart@uiuc.edu) */
! 63:
! 64: /* Since it took me a little while to figure out what is happening,
! 65: * I may as well write it down.
! 66: * There are three length scales of interest: inches, points
! 67: * and dots. inches are obvious. points are the usual typesetting
! 68: * thing (ie approx 72 points per inch). This driver works in
! 69: * units of dots, which corresponds to pixels on a 300 DPI printer.
! 70: * We do a \setlength{unitlength}{...pt} to make teX work in
! 71: * terms of dots. The ... is called LATEX_UNIT in here.
! 72: * The reason I had to get involved in all of this is because
! 73: * font size (in pts) was not being scaled up by DOTS_PER_POINT
! 74: * - drd, Sept 1996
! 75: */
! 76:
! 77: #include "driver.h"
! 78:
! 79: #ifdef TERM_REGISTER
! 80: register_term(latex)
! 81: #ifdef EMTEX
! 82: register_term(emtex)
! 83: #endif
! 84: #endif
! 85:
! 86: #ifdef TERM_PROTO
! 87: TERM_PUBLIC void LATEX_options __PROTO((void));
! 88: TERM_PUBLIC void LATEX_init __PROTO((void));
! 89: TERM_PUBLIC void LATEX_graphics __PROTO((void));
! 90: TERM_PUBLIC void LATEX_text __PROTO((void));
! 91: TERM_PUBLIC void LATEX_put_text __PROTO((unsigned int x, unsigned int y, char str[]));
! 92: TERM_PUBLIC void LATEX_linetype __PROTO((int linetype));
! 93: TERM_PUBLIC void LATEX_move __PROTO((unsigned int x, unsigned int y));
! 94: TERM_PUBLIC void LATEX_point __PROTO((unsigned int x, unsigned int y, int number));
! 95: TERM_PUBLIC void LATEX_vector __PROTO((unsigned int ux, unsigned int uy));
! 96: TERM_PUBLIC void LATEX_arrow __PROTO((unsigned int sx, unsigned int sy, unsigned int ex, unsigned int ey, TBOOLEAN head));
! 97: TERM_PUBLIC int LATEX_justify_text __PROTO((enum JUSTIFY mode));
! 98: TERM_PUBLIC int LATEX_text_angle __PROTO((int ang));
! 99: TERM_PUBLIC void LATEX_reset __PROTO((void));
! 100:
! 101: #ifdef EMTEX
! 102: TERM_PUBLIC void EMTEX_init __PROTO((void));
! 103: TERM_PUBLIC void EMTEX_reset __PROTO((void));
! 104: TERM_PUBLIC void EMTEX_text __PROTO((void));
! 105: #endif
! 106:
! 107: #define TINY_STEP 0.5 /* tiny steps for high quality lines */
! 108:
! 109: #define LATEX_PTS_PER_INCH (72.27)
! 110: #define DOTS_PER_INCH (300) /* resolution of printer we expect to use */
! 111: #define LATEX_UNIT (LATEX_PTS_PER_INCH/DOTS_PER_INCH) /* dot size in pt */
! 112:
! 113: /* 5 inches wide by 3 inches high (default) */
! 114: #define LATEX_XMAX (5*DOTS_PER_INCH) /* (LATEX_PTS_PER_INCH/LATEX_UNIT*5.0) */
! 115: #define LATEX_YMAX (3*DOTS_PER_INCH) /* (LATEX_PTS_PER_INCH/LATEX_UNIT*3.0) */
! 116:
! 117: #define LATEX_HTIC (5*DOTS_PER_INCH/72) /* (5 pts) */
! 118: #define LATEX_VTIC (5*DOTS_PER_INCH/72) /* (5 pts) */
! 119: #define LATEX_HCHAR (DOTS_PER_INCH*53/10/72) /* (5.3 pts) */
! 120: #define LATEX_VCHAR (DOTS_PER_INCH*11/72) /* (11 pts) */
! 121: #endif
! 122:
! 123:
! 124: #ifndef TERM_PROTO_ONLY
! 125: #ifdef TERM_BODY
! 126:
! 127: static int LATEX_posx;
! 128: static int LATEX_posy;
! 129: static int LATEX_fontsize = 10;
! 130: static char LATEX_font[MAX_ID_LEN+1] = "cmr";
! 131: static enum JUSTIFY latex_justify = LEFT;
! 132: static int latex_angle = 0;
! 133:
! 134: /* Default line-drawing character */
! 135: /* the definition of plotpoint varies with linetype */
! 136: #define LATEX_DOT "\\usebox{\\plotpoint}"
! 137: #define LATEX_TINY_DOT "\\rule{1pt}{1pt}" /* for dots plot style */
! 138:
! 139: /* POINTS */
! 140: #define LATEX_POINT_TYPES 12 /* we supply more point types */
! 141: static char GPFAR *GPFAR LATEX_points[] =
! 142: {
! 143: "\\raisebox{-.8pt}{\\makebox(0,0){$\\Diamond$}}",
! 144: "\\makebox(0,0){$+$}",
! 145: "\\raisebox{-.8pt}{\\makebox(0,0){$\\Box$}}",
! 146: "\\makebox(0,0){$\\times$}",
! 147: "\\makebox(0,0){$\\triangle$}",
! 148: "\\makebox(0,0){$\\star$}",
! 149: "\\circle{12}", "\\circle{18}", "\\circle{24}",
! 150: "\\circle*{12}", "\\circle*{18}", "\\circle*{24}"
! 151: };
! 152:
! 153: /* LINES */
! 154: static float LATEX_size = 0; /* current thick of line in points */
! 155: static float LATEX_dotspace = 0; /* current dotspace of line in points */
! 156: #define LATEX_LINE_TYPES 6 /* number of line types below */
! 157: #define LATEX_THIN_LINE 0 /* the thinnest solid line type */
! 158: static struct {
! 159: float size; /* size of dot, or thick of line in points */
! 160: float dotspace; /* inter-dot space in points; 0 for lines */
! 161: } GPFAR LATEX_lines[] =
! 162:
! 163: {
! 164: {0.4, 0.0}, /* thin solid line */
! 165: {0.4, 5.0}, /* thin dotted line */
! 166: {0.8, 0.0}, /* thick solid line */
! 167: {1.0, 5.0}, /* thick dotted line */
! 168: {1.2, 0.0}, /* Thick solid line */
! 169: {1.0, 10.0}, /* thick widely dotted line */
! 170: };
! 171:
! 172: /* for drawing dotted and solid lines */
! 173: static void LATEX_dot_line __PROTO((int x1, int x2, int y1, int y2));
! 174: static void LATEX_solid_line __PROTO((int x1, int x2, int y1, int y2));
! 175: static void LATEX_rule __PROTO((int code, double x, double y, double width, double height));
! 176: static void LATEX_flushdot __PROTO((void));
! 177: #define LATEX_flushrule() LATEX_rule(2, 0.,0.,0.,0.) /* flush old rule */
! 178: static TBOOLEAN LATEX_moved = TRUE; /* pen is up after move */
! 179: static float LATEX_dotsize; /* size of LATEX_DOT in units */
! 180: static TBOOLEAN LATEX_needsdot = FALSE; /* does dotted line need termination? */
! 181:
! 182: #ifdef EMTEX
! 183: TBOOLEAN emtex = FALSE; /* not currently using emtex */
! 184: static void
! 185: EMTEX_solid_line __PROTO((int x1, int x2, int y1, int y2));
! 186: #endif
! 187:
! 188: /* ARROWS */
! 189: /* the set of non-vertical/non-horizontal LaTeX vector slopes */
! 190: /* except negatives - they are handled specially */
! 191: static struct vslope {
! 192: int dx, dy;
! 193: } GPFAR LATEX_slopes[] =
! 194:
! 195: {
! 196: {1, 1},
! 197: {1, 2},
! 198: {1, 3},
! 199: {1, 4},
! 200: {2, 1},
! 201: {2, 3},
! 202: {3, 1},
! 203: {3, 2},
! 204: {3, 4},
! 205: {4, 1},
! 206: {4, 3},
! 207: {0, 0} /* terminator */
! 208: };
! 209:
! 210: /* figure out the best arrow */
! 211: void best_latex_arrow __PROTO((int, int, int, int, int, TBOOLEAN));
! 212:
! 213: TERM_PUBLIC void LATEX_options()
! 214: {
! 215: if (!END_OF_COMMAND) {
! 216: if (almost_equals(c_token, "c$ourier")) {
! 217: strcpy(LATEX_font, "cmtt");
! 218: c_token++;
! 219: } else if (almost_equals(c_token, "r$oman")) {
! 220: strcpy(LATEX_font, "cmr");
! 221: c_token++;
! 222: } else if (almost_equals(c_token, "d$efault")) {
! 223: strcpy(LATEX_font, "cmr");
! 224: LATEX_fontsize = 10;
! 225: c_token++;
! 226: }
! 227: }
! 228: if (!END_OF_COMMAND) {
! 229: struct value a;
! 230: LATEX_fontsize = (int) real(const_express(&a));
! 231: }
! 232: /* tell gnuplot core about char. sizes. Horizontal spacing
! 233: * is about half the text pointsize
! 234: */
! 235: term->v_char = (unsigned int) (LATEX_fontsize * DOTS_PER_INCH / 72);
! 236: term->h_char = (unsigned int) (LATEX_fontsize * DOTS_PER_INCH / 144);
! 237:
! 238: sprintf(term_options, "%s %d", LATEX_font[2] == 't' ? "courier" : "roman",
! 239: LATEX_fontsize);
! 240: }
! 241:
! 242:
! 243: TERM_PUBLIC void LATEX_init()
! 244: {
! 245: #ifdef EMTEX
! 246: emtex = FALSE;
! 247: #endif
! 248: LATEX_posx = LATEX_posy = 0;
! 249:
! 250: fprintf(gpoutfile, "\
! 251: %% GNUPLOT: LaTeX picture\n\
! 252: \\setlength{\\unitlength}{%fpt}\n\
! 253: \\ifx\\plotpoint\\undefined\\newsavebox{\\plotpoint}\\fi\n",
! 254: LATEX_UNIT);
! 255:
! 256: LATEX_linetype(-1);
! 257: LATEX_size = 0;
! 258: }
! 259:
! 260: TERM_PUBLIC void LATEX_graphics()
! 261: {
! 262: register struct termentry *t = term;
! 263:
! 264: /* bounding box */
! 265: int xscale = xsize * t->xmax;
! 266: int yscale = ysize * t->ymax;
! 267:
! 268: fprintf(gpoutfile, "\
! 269: \\begin{picture}(%d,%d)(0,0)\n\
! 270: \\font\\gnuplot=%s10 at %dpt\n\
! 271: \\gnuplot\n",
! 272: xscale, yscale,
! 273: LATEX_font, LATEX_fontsize);
! 274: }
! 275:
! 276:
! 277: TERM_PUBLIC void LATEX_text()
! 278: {
! 279: LATEX_flushrule();
! 280: LATEX_flushdot();
! 281: fputs("\\end{picture}\n", gpoutfile);
! 282: LATEX_posx = LATEX_posy = 0; /* current position */
! 283: LATEX_moved = TRUE; /* pen is up after move */
! 284: }
! 285:
! 286: TERM_PUBLIC void LATEX_linetype(linetype)
! 287: int linetype;
! 288: {
! 289: float size;
! 290:
! 291: if (linetype >= LATEX_LINE_TYPES)
! 292: linetype %= LATEX_LINE_TYPES;
! 293:
! 294: #ifdef EMTEX
! 295: if (!emtex)
! 296: #endif
! 297: LATEX_flushrule();
! 298: LATEX_flushdot();
! 299:
! 300: /* Find the new desired line thickness. */
! 301: /* negative linetypes (for axes) use a thin line */
! 302: /* only relevant for drawing axes/border in 3d */
! 303: size = (linetype >= 0 ? LATEX_lines[linetype].size
! 304: : LATEX_lines[LATEX_THIN_LINE].size);
! 305:
! 306: /* If different from current size, redefine \plotpoint */
! 307: if (size != LATEX_size) {
! 308: fprintf(gpoutfile,
! 309: "\\sbox{\\plotpoint}{\\rule[%.3fpt]{%.3fpt}{%.3fpt}}%%\n",
! 310: -size / 2, size, size);
! 311: #ifdef EMTEX
! 312: if (emtex) /* change line width */
! 313: fprintf(gpoutfile, "\\special{em:linewidth %.1fpt}%%\n", size);
! 314: #endif
! 315: }
! 316: LATEX_size = size;
! 317: LATEX_dotsize = size / LATEX_UNIT;
! 318: LATEX_dotspace = (linetype >= 0) ? LATEX_lines[linetype].dotspace : 0;
! 319: LATEX_moved = TRUE; /* reset */
! 320: }
! 321:
! 322: TERM_PUBLIC void LATEX_move(x, y)
! 323: unsigned int x, y;
! 324: {
! 325: LATEX_flushdot();
! 326:
! 327: LATEX_posx = x;
! 328: LATEX_posy = y;
! 329: LATEX_moved = TRUE; /* reset */
! 330: }
! 331:
! 332:
! 333: TERM_PUBLIC void LATEX_point(x, y, number) /* version of line_and_point */
! 334: unsigned int x, y;
! 335: int number; /* type of point */
! 336: {
! 337: LATEX_move(x, y);
! 338:
! 339: /* Print the character defined by 'number'; number < 0 means
! 340: to use a dot, otherwise one of the defined points. */
! 341: fprintf(gpoutfile, "\\put(%d,%d){%s}\n", x, y,
! 342: (number < 0 ? LATEX_TINY_DOT
! 343: : LATEX_points[number % LATEX_POINT_TYPES]));
! 344: }
! 345:
! 346:
! 347: TERM_PUBLIC void LATEX_vector(ux, uy)
! 348: unsigned int ux, uy;
! 349: {
! 350: if (LATEX_dotspace == 0.0) {
! 351: /* solid line */
! 352: #ifdef EMTEX
! 353: if (emtex)
! 354: EMTEX_solid_line(LATEX_posx, (int) ux, LATEX_posy, (int) uy);
! 355: else
! 356: #endif
! 357: LATEX_solid_line(LATEX_posx, (int) ux, LATEX_posy, (int) uy);
! 358: } else
! 359: /* dotted line */
! 360: LATEX_dot_line(LATEX_posx, (int) ux, LATEX_posy, (int) uy);
! 361:
! 362: LATEX_posx = ux;
! 363: LATEX_posy = uy;
! 364: }
! 365:
! 366: static void LATEX_solid_line(x1, x2, y1, y2)
! 367: int x1, x2, y1, y2;
! 368: {
! 369: float slope;
! 370: int inc;
! 371: float dx, dy, x, y;
! 372: float offset, length;
! 373: int code; /* possibly combine with previous rule */
! 374:
! 375: /* we draw a solid line using the current line thickness (size) */
! 376: /* we do it with lots of \\rules */
! 377:
! 378: if (x1 == x2 && y1 == y2) { /* zero-length line - just a dot */
! 379: if (LATEX_moved) {
! 380: LATEX_flushrule();
! 381: /* plot a dot */
! 382: fprintf(gpoutfile, "\\put(%u,%u){%s}\n", x1, y1, LATEX_DOT);
! 383: }
! 384: } else {
! 385: code = (LATEX_moved ? 0 : 1); /* no combine after move */
! 386: LATEX_moved = FALSE;
! 387: if (x1 == x2) /* vertical line - special case */
! 388: LATEX_rule(code, (double) x1, (double) y1,
! 389: LATEX_dotsize, (double) y2 - y1);
! 390: else if (y1 == y2) /* horizontal line - special case */
! 391: LATEX_rule(code, (double) x1, (double) y1, (double) x2 - x1,
! 392: LATEX_dotsize);
! 393: else {
! 394: dx = (float) x2 - x1;
! 395: dy = (float) y2 - y1;
! 396: slope = dy / dx;
! 397: if (ABS(slope) <= 1.0) {
! 398: /* longer than high */
! 399: x = GPMIN(ABS(dx), (0.25 + 1.0 / ABS(slope)) * LATEX_dotsize);
! 400: offset = sign(dy) * GPMIN(LATEX_dotsize, ABS(dy));
! 401: dy = dy - offset;
! 402: length = x * LATEX_UNIT;
! 403: inc = (x == ABS(dx) ? 1 : GPMAX(1, ABS(dy) / TINY_STEP + 0.5));
! 404: if (inc == 1) {
! 405: fprintf(gpoutfile, "\\put(%u,%.2f){\\rule{%.3fpt}{%.3fpt}}\n",
! 406: (x2 >= x1 ? x1 : x2), ((float) y1 + y2 - LATEX_dotsize) / 2,
! 407: length, LATEX_dotsize * LATEX_UNIT);
! 408: } else {
! 409: dy = dy / inc;
! 410: dx = (dx - sign(dx) * x) / (inc - 1);
! 411: fprintf(gpoutfile,
! 412: "\\multiput(%.2f,%.2f)(%.3f,%.3f){%u}{\\rule{%.3fpt}{%.3fpt}}\n",
! 413: (dx >= 0.0 ? (float) x1 : x1 - x),
! 414: (float) y1 - (ABS(dy) - offset) / 2,
! 415: dx, dy, inc, length, ABS(dy) * LATEX_UNIT);
! 416: }
! 417: /* done with one section, now smooth it */
! 418: x = x / 2;
! 419: dx = sign(dx) * x;
! 420: dx = (float) x2 - x1 - dx;
! 421: dy = (float) y2 - y1;
! 422: fprintf(gpoutfile, "\\multiput(%.2f,%.2f)(%.3f,%.3f){2}{\\rule{%.3fpt}{%.3fpt}}\n",
! 423: (dx >= 0.0 ? (float) x1 : x1 - x), (float) y1 - LATEX_dotsize / 2,
! 424: dx, dy, x * LATEX_UNIT, LATEX_dotsize * LATEX_UNIT);
! 425: LATEX_moved = TRUE;
! 426: } else {
! 427: /* higher than long */
! 428: y = GPMIN(ABS(dy), (0.25 + ABS(slope)) * LATEX_dotsize);
! 429: offset = sign(dx) * GPMIN(LATEX_dotsize, ABS(dx));
! 430: dx = dx - offset;
! 431: length = y * LATEX_UNIT;
! 432: inc = (y == ABS(dy) ? 1 : GPMAX(1, ABS(dx) / TINY_STEP + 0.5));
! 433: if (inc == 1) {
! 434: fprintf(gpoutfile, "\\put(%.2f,%u){\\rule{%.3fpt}{%.3fpt}}\n",
! 435: ((float) x1 + x2 - LATEX_dotsize) / 2, (y2 >= y1 ? y1 : y2),
! 436: LATEX_dotsize * LATEX_UNIT, length);
! 437: } else {
! 438: dx = dx / inc;
! 439: dy = (dy - sign(dy) * y) / (inc - 1);
! 440: fprintf(gpoutfile,
! 441: "\\multiput(%.2f,%.2f)(%.3f,%.3f){%u}{\\rule{%.3fpt}{%.3fpt}}\n",
! 442: (float) x1 - (ABS(dx) - offset) / 2,
! 443: (dy >= 0 ? (float) y1 : y1 - y),
! 444: dx, dy, inc, ABS(dx) * LATEX_UNIT, length);
! 445: }
! 446: /* done with one section, now smooth it */
! 447: y = y / 2;
! 448: dx = (float) x2 - x1;
! 449: dy = sign(dy) * y;
! 450: dy = (float) y2 - y1 - dy;
! 451: fprintf(gpoutfile, "\\multiput(%.2f,%.2f)(%.3f,%.3f){2}{\\rule{%.3fpt}{%.3fpt}}\n",
! 452: (float) x1 - LATEX_dotsize / 2, (dy >= 0.0 ? (float) y1 : y1 - y),
! 453: dx, dy, LATEX_dotsize * LATEX_UNIT, y * LATEX_UNIT);
! 454: LATEX_moved = TRUE;
! 455: }
! 456: }
! 457: }
! 458: }
! 459:
! 460: /* Draw a \rule. Width or height may be negative; we can correct.
! 461: * The rule is never output immediately. The previous rule is output
! 462: * as-is if code is 0, and the previous rule is
! 463: * combined with the current rule (if possible) if code is 1.
! 464: * The previous rule is output, and the new one ignored, if code is 2.
! 465: */
! 466: static void LATEX_rule(code, x, y, width, height)
! 467: int code; /* how do we treat this rule? */
! 468: double x, y;
! 469: double width;
! 470: double height;
! 471: {
! 472: static float lastx, lasty;
! 473: static float lastw, lasth;
! 474: static TBOOLEAN isvalid = FALSE; /* is 'last' data valid? */
! 475: TBOOLEAN combine = (code == 1);
! 476: TBOOLEAN flush = (code == 2);
! 477:
! 478: if (!flush)
! 479: if (width == 0 || height == 0)
! 480: return; /* ignore this rule */
! 481:
! 482: if (isvalid && combine) {
! 483: /* try to combine new rule with old rule */
! 484: if ((int) lastx == (int) x && lastw == width) { /* vertical rule */
! 485: if (lasth * height >= 0) { /* same sign */
! 486: lasth += height;
! 487: return;
! 488: }
! 489: } else if ((int) lasty == (int) y && lasth == height) { /* horiz rule */
! 490: if (lastw * width >= 0) { /* same sign */
! 491: lastw += width;
! 492: return;
! 493: }
! 494: }
! 495: /* oh well, output last and remember the new one */
! 496: }
! 497: if (isvalid) {
! 498: /* output the rule */
! 499: if (lastw < 0) {
! 500: lastx += lastw;
! 501: lastw = -lastw;
! 502: }
! 503: if (lasth < 0) {
! 504: lasty += lasth;
! 505: lasth = -lasth;
! 506: }
! 507: /* if very small use canned dot */
! 508: if (lastw < LATEX_dotsize || lasth < LATEX_dotsize)
! 509: fprintf(gpoutfile, "\\put(%.1f,%.1f){%s}\n",
! 510: lastx, lasty, LATEX_DOT);
! 511: else
! 512: fprintf(gpoutfile, "\\put(%.1f,%.1f){\\rule[%.3fpt]{%.3fpt}{%.3fpt}}\n",
! 513: lastx, lasty, -LATEX_dotsize * LATEX_UNIT / 2,
! 514: lastw * LATEX_UNIT, lasth * LATEX_UNIT);
! 515: }
! 516: if (flush) {
! 517: isvalid = FALSE;
! 518: } else {
! 519: lastx = x;
! 520: lasty = y;
! 521: lastw = width;
! 522: lasth = height;
! 523: isvalid = TRUE;
! 524: }
! 525: }
! 526:
! 527: static void LATEX_dot_line(x1, x2, y1, y2)
! 528: int x1, x2, y1, y2;
! 529: {
! 530: static float LATEX_left; /* fraction of space left after last dot */
! 531:
! 532: /* we draw a dotted line using the current dot spacing */
! 533:
! 534: if (LATEX_moved)
! 535: LATEX_left = 1.0; /* reset after a move */
! 536:
! 537: /* zero-length line? */
! 538: if (x1 == x2 && y1 == y2) {
! 539: if (LATEX_moved)
! 540: /* plot a dot */
! 541: fprintf(gpoutfile, "\\put(%u,%u){%s}\n", x1, y1, LATEX_DOT);
! 542: } else {
! 543: float dotspace = LATEX_dotspace / LATEX_UNIT;
! 544: float x, y; /* current position */
! 545: float xinc, yinc; /* increments */
! 546: float slope; /* slope of line */
! 547: float lastx = -1; /* last x point plotted */
! 548: float lasty = -1; /* last y point plotted */
! 549: int numdots = 0; /* number of dots in this section */
! 550:
! 551: /* first, figure out increments for x and y */
! 552: if (x2 == x1) {
! 553: xinc = 0.0;
! 554: yinc = (y2 - y1 > 0) ? dotspace : -dotspace;
! 555: } else {
! 556: slope = ((float) y2 - y1) / ((float) x2 - x1);
! 557: xinc = dotspace / sqrt(1 + slope * slope) * sign(x2 - x1);
! 558: yinc = slope * xinc;
! 559: }
! 560:
! 561: /* now draw the dotted line */
! 562: /* we take into account where we last placed a dot */
! 563: for (x = x1 + xinc * (1 - LATEX_left), y = y1 + yinc * (1 - LATEX_left);
! 564: (x2 - x) * xinc >= 0 && (y2 - y) * yinc >= 0; /* same sign or zero */
! 565: lastx = x, x += xinc,
! 566: lasty = y, y += yinc)
! 567: numdots++;
! 568: if (numdots == 1)
! 569: fprintf(gpoutfile, "\\put(%.2f,%.2f){%s}\n",
! 570: lastx, lasty, LATEX_DOT);
! 571: else if (numdots > 0)
! 572: fprintf(gpoutfile, "\\multiput(%u,%u)(%.3f,%.3f){%u}{%s}\n",
! 573: x1, y1, xinc, yinc, numdots, LATEX_DOT);
! 574:
! 575: /* how much is left over, as a fraction of dotspace? */
! 576: if (xinc != 0.0) /* xinc must be nonzero */
! 577: if (lastx >= 0)
! 578: LATEX_left = ABS(x2 - lastx) / ABS(xinc);
! 579: else
! 580: LATEX_left += ABS(x2 - x1) / ABS(xinc);
! 581: else if (lasty >= 0)
! 582: LATEX_left = ABS(y2 - lasty) / ABS(yinc);
! 583: else
! 584: LATEX_left += ABS(y2 - y1) / ABS(yinc);
! 585: }
! 586:
! 587: LATEX_needsdot = (LATEX_left > 0);
! 588:
! 589: LATEX_moved = FALSE;
! 590: }
! 591:
! 592: static void LATEX_flushdot()
! 593: {
! 594: if (LATEX_needsdot)
! 595: fprintf(gpoutfile, "\\put(%d,%d){%s}\n",
! 596: LATEX_posx, LATEX_posy, LATEX_DOT);
! 597: LATEX_needsdot = FALSE;
! 598: }
! 599:
! 600: TERM_PUBLIC void LATEX_arrow(sx, sy, ex, ey, head)
! 601: unsigned int sx, sy, ex, ey;
! 602: TBOOLEAN head;
! 603: {
! 604: best_latex_arrow(sx, sy, ex, ey, 1, head);
! 605:
! 606: LATEX_posx = ex;
! 607: LATEX_posy = ey;
! 608: }
! 609:
! 610: void best_latex_arrow(sx, sy, ex, ey, who, head)
! 611: int sx, sy, ex, ey; /* start and end points */
! 612: int who; /* 1=LATEX, 2=EEPIC */
! 613: TBOOLEAN head;
! 614: {
! 615: int dx = ex - sx;
! 616: int dy = ey - sy;
! 617: float m; /* slope of line */
! 618: float arrowslope; /* slope of arrow */
! 619: float minerror = 0; /* best-case error */
! 620: struct vslope *slope; /* one of the slopes */
! 621: struct vslope *bestslope; /* the slope with min error */
! 622:
! 623: /* We try to draw a real arrow (ie, \vector). If we can't get
! 624: * a slope that is close, we draw a bent arrow.
! 625: */
! 626:
! 627: if (dx == 0) {
! 628: /* vertical arrow */
! 629: fprintf(gpoutfile, "\\put(%d,%d){\\%s(0,%d){%d}}\n",
! 630: sx, sy, head ? "vector" : "line",
! 631: sign(ey - sy), ABS(ey - sy));
! 632: } else if (dy == 0) {
! 633: /* horizontal arrow */
! 634: fprintf(gpoutfile, "\\put(%d,%d){\\%s(%d,0){%d}}\n",
! 635: sx, sy, head ? "vector" : "line",
! 636: sign(ex - sx), ABS(ex - sx));
! 637: } else {
! 638: /* Slanted arrow. We'll give it a try.
! 639: * we try to find the closest-slope arrowhead.
! 640: */
! 641: bestslope = NULL;
! 642: minerror = 0; /* to shut up turbo C */
! 643: m = ABS((float) dy / dx); /* the slope we want */
! 644: for (slope = LATEX_slopes; slope->dx != 0.0; slope++) {
! 645: /* find the slope of the arrow */
! 646: arrowslope = (float) slope->dy / slope->dx;
! 647: if (bestslope == NULL || ABS(m - arrowslope) < minerror) {
! 648: minerror = ABS(m - arrowslope);
! 649: bestslope = slope;
! 650: }
! 651: }
! 652:
! 653: /* now we have the best slope arrow */
! 654: /* maybe it's exactly the right slope! */
! 655: if (minerror == 0.0) /* unlikely but possible */
! 656: fprintf(gpoutfile, "\\put(%d,%d){\\%s(%d,%d){%d}}\n",
! 657: sx, sy, head ? "vector" : "line",
! 658: bestslope->dx * sign(ex - sx), bestslope->dy * sign(ey - sy),
! 659: ABS(ex - sx));
! 660: else {
! 661: /* we draw the line the usual way, with thin lines */
! 662: #ifdef EMTEX
! 663: if (emtex) {
! 664: LATEX_linetype(LATEX_THIN_LINE);
! 665: EMTEX_solid_line(sx, ex, sy, ey);
! 666: } else
! 667: #endif
! 668: if (who == 1) {
! 669: LATEX_linetype(LATEX_THIN_LINE);
! 670: LATEX_solid_line(sx, ex, sy, ey);
! 671: }
! 672: #ifdef EEPIC
! 673: else {
! 674: EEPIC_move(sx, sy);
! 675: EEPIC_vector(ex, ey);
! 676: }
! 677: #endif /* EEPIC */
! 678: /* and then draw an arrowhead (a short vector) there */
! 679: if (head)
! 680: fprintf(gpoutfile, "\\put(%d,%d){\\vector(%d,%d){0}}\n",
! 681: ex, ey,
! 682: bestslope->dx * sign(ex - sx), bestslope->dy * sign(ey - sy));
! 683: }
! 684: }
! 685: }
! 686:
! 687: TERM_PUBLIC void LATEX_put_text(x, y, str)
! 688: unsigned int x, y; /* reference point of string */
! 689: char str[]; /* the text */
! 690: {
! 691: static char *justify[] =
! 692: {"[l]", "", "[r]"};
! 693: int flag, i;
! 694:
! 695: /* ignore empty strings */
! 696: if (str[0] == NUL)
! 697: return;
! 698:
! 699: for (flag = FALSE, i = 0; str[i] && !flag;)
! 700: flag = (str[i++] == '\\') && (str[i++] == '\\');
! 701:
! 702: fprintf(gpoutfile, "\\put(%d,%d)", x, y);
! 703: if ((str[0] == '{') || (str[0] == '[')) {
! 704: fprintf(gpoutfile, "{\\makebox(0,0)%s}\n", str);
! 705: } else if (flag)
! 706: fprintf(gpoutfile, "{\\makebox(0,0)%s{\\shortstack{%s}}}\n",
! 707: justify[latex_justify], str);
! 708: else
! 709: fprintf(gpoutfile, "{\\makebox(0,0)%s{%s}}\n",
! 710: justify[latex_justify], str);
! 711: }
! 712:
! 713: TERM_PUBLIC int LATEX_justify_text(mode)
! 714: enum JUSTIFY mode;
! 715: {
! 716: latex_justify = mode;
! 717: return (TRUE);
! 718: }
! 719:
! 720: TERM_PUBLIC int LATEX_text_angle(ang)
! 721: int ang;
! 722: {
! 723: /* we can't really write text vertically, but this will
! 724: put the ylabel centred at the left of the plot, and
! 725: then we'll make a \shortstack */
! 726: latex_angle = ang;
! 727: return (TRUE);
! 728: }
! 729:
! 730: TERM_PUBLIC void LATEX_reset()
! 731: {
! 732: LATEX_posx = LATEX_posy = 0; /* current position */
! 733: LATEX_moved = TRUE; /* pen is up after move */
! 734: }
! 735:
! 736:
! 737: #ifdef EMTEX
! 738:
! 739: TERM_PUBLIC void EMTEX_init()
! 740: {
! 741: emtex = TRUE;
! 742: LATEX_posx = LATEX_posy = 0;
! 743: fprintf(gpoutfile, "\
! 744: %% GNUPLOT: LaTeX picture with emtex specials\n\
! 745: \\setlength{\\unitlength}{%fpt}\n\
! 746: \\ifx\\plotpoint\\undefined\\newsavebox{\\plotpoint}\\fi\n",
! 747: LATEX_UNIT);
! 748: LATEX_linetype(-1);
! 749: }
! 750:
! 751:
! 752: TERM_PUBLIC void EMTEX_reset()
! 753: {
! 754: emtex = FALSE;
! 755: LATEX_posx = LATEX_posy = 0;
! 756: }
! 757:
! 758:
! 759: TERM_PUBLIC void EMTEX_text()
! 760: {
! 761: fputs("\\end{picture}\n", gpoutfile);
! 762: }
! 763:
! 764:
! 765: static void EMTEX_solid_line(x1, x2, y1, y2)
! 766: int x1, x2, y1, y2;
! 767: {
! 768: /* emtex special solid line */
! 769: if (LATEX_moved)
! 770: fprintf(gpoutfile, "\\put(%d,%d){\\special{em:moveto}}\n", x1, y1);
! 771: if ((x1 != x2) || (y1 != y2))
! 772: fprintf(gpoutfile, "\\put(%d,%d){\\special{em:lineto}}\n", x2, y2);
! 773: LATEX_posx = x2;
! 774: LATEX_posy = y2;
! 775: LATEX_moved = FALSE;
! 776: }
! 777:
! 778:
! 779: #endif /* EMTEX */
! 780:
! 781: #endif /* TERM_BODY */
! 782: #endif /* TERM_PROTO_ONLY */
! 783:
! 784: #ifdef TERM_TABLE
! 785:
! 786: TERM_TABLE_START(latex_driver)
! 787: "latex", "LaTeX picture environment",
! 788: LATEX_XMAX, LATEX_YMAX, LATEX_VCHAR, LATEX_HCHAR,
! 789: LATEX_VTIC, LATEX_HTIC, LATEX_options, LATEX_init, LATEX_reset,
! 790: LATEX_text, null_scale, LATEX_graphics, LATEX_move, LATEX_vector,
! 791: LATEX_linetype, LATEX_put_text, LATEX_text_angle,
! 792: LATEX_justify_text, LATEX_point, LATEX_arrow, set_font_null
! 793: TERM_TABLE_END(latex_driver)
! 794:
! 795: #undef LAST_TERM
! 796: #define LAST_TERM latex_driver
! 797:
! 798:
! 799: #ifdef EMTEX
! 800: TERM_TABLE_START(emtex_driver)
! 801: "emtex", "LaTeX picture environment with emTeX specials",
! 802: LATEX_XMAX, LATEX_YMAX, LATEX_VCHAR, LATEX_HCHAR,
! 803: LATEX_VTIC, LATEX_HTIC, LATEX_options, EMTEX_init, EMTEX_reset,
! 804: EMTEX_text, null_scale, LATEX_graphics, LATEX_move, LATEX_vector,
! 805: LATEX_linetype, LATEX_put_text, LATEX_text_angle,
! 806: LATEX_justify_text, LATEX_point, LATEX_arrow, set_font_null
! 807: TERM_TABLE_END(emtex_driver)
! 808:
! 809: #undef LAST_TERM
! 810: #define LAST_TERM emtex_driver
! 811:
! 812: #endif /* EMTEX */
! 813: #endif /* TERM_TABLE */
! 814:
! 815:
! 816: #ifdef TERM_HELP
! 817: START_HELP(latex)
! 818: "1 latex",
! 819: "?commands set terminal emtex",
! 820: "?set terminal emtex",
! 821: "?set term emtex",
! 822: "?terminal emtex",
! 823: "?term emtex",
! 824: "?latex",
! 825: "?commands set terminal latex",
! 826: "?set terminal latex",
! 827: "?set term latex",
! 828: "?terminal latex",
! 829: "?term latex",
! 830: "?emtex",
! 831: " The `latex` and `emtex` drivers allow two options.",
! 832: "",
! 833: " Syntax:",
! 834: " set terminal latex | emtex {courier | roman} {<fontsize>}",
! 835: "",
! 836: " `fontsize` may be any size you specify. The default is 10-point Roman.",
! 837: "",
! 838: " Unless your driver is capable of building fonts at any size (e.g. dvips),",
! 839: " stick to the standard 10, 11 and 12 point sizes.",
! 840: "",
! 841: " METAFONT users beware: METAFONT does not like odd sizes.",
! 842: "",
! 843: " All drivers for LaTeX offer a special way of controlling text positioning:",
! 844: " If any text string begins with '{', you also need to include a '}' at the",
! 845: " end of the text, and the whole text will be centered both horizontally",
! 846: " and vertically by LaTeX. --- If the text string begins with '[', you need",
! 847: " to continue it with: a position specification (up to two out of t,b,l,r),",
! 848: " ']{', the text itself, and finally, '}'. The text itself may be anything",
! 849: " LaTeX can typeset as an LR-box. \\rule{}{}'s may help for best positioning.",
! 850: "",
! 851: " Examples:",
! 852: " About label positioning:",
! 853: " Use gnuplot defaults (mostly sensible, but sometimes not really best):",
! 854: " set title '\\LaTeX\\ -- $ \\gamma $'",
! 855: " Force centering both horizontally and vertically:",
! 856: " set label '{\\LaTeX\\ -- $ \\gamma $}' at 0,0",
! 857: " Specify own positioning (top here):",
! 858: " set xlabel '[t]{\\LaTeX\\ -- $ \\gamma $}'",
! 859: " The other label -- account for long ticlabels:",
! 860: " set ylabel '[r]{\\LaTeX\\ -- $ \\gamma $\\rule{7mm}{0pt}'"
! 861: END_HELP(latex)
! 862: #endif /* TERM_TABLE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to latex.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term