Annotation of OpenXM_contrib/gnuplot/term/pstricks.trm, Revision 1.1
1.1 ! maekawa 1: /* Hey Emacs this is -*- C -*-
! 2: *
! 3: * $Id: pstricks.trm,v 1.16 1998/06/18 14:59:25 ddenholm Exp $
! 4: */
! 5:
! 6: /* GNUPLOT - pstricks.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: * The PSTricks macros for LaTeX.
! 43: *
! 44: * AUTHORS
! 45: * David Kotz
! 46: *
! 47: * Raymond Toy toy@soho.crd.ge.com
! 48: * Modified the eepic.trm file to use PSTricks macros instead.
! 49: *
! 50: * 20 Mar 93:
! 51: * Utilized many suggestions from Gisli Ottarsson
! 52: * (gisli@liapunov.eecs.umich.edu) to create a new version.
! 53: * Should also work with TeX as well as LaTeX.
! 54: *
! 55: * If you have PSTricks version 0.91, #define OLD_PST to
! 56: * get the right dots.
! 57: *
! 58: * Added a really ugly hack (enabled by default) to print
! 59: * "nice" numbers for axis labels. This should really be at
! 60: * a higher level in the code, but I'm lazy right now.
! 61: *
! 62: * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
! 63: *
! 64: */
! 65:
! 66: /*
! 67: * This file contains the PSTricks terminal driver, intended for use with the
! 68: * pstricks.sty macro package for LaTeX. This is an alternative to the
! 69: * eepic and latex driver. You need pstricks.sty, and, of course, a printer
! 70: * that understands PostScript. Ghostscript understands Postscript too.
! 71: *
! 72: * PSTricks is available via anonymous ftp from the /pub directory
! 73: * at Princeton.EDU. This driver definitely does not come close to
! 74: * using the full capability of the PSTricks package.
! 75: */
! 76: /*
! 77: * adapted to the new terminal layout by Stefan Bodewig (Dec. 1995)
! 78: */
! 79:
! 80: #include "driver.h"
! 81:
! 82: #ifdef TERM_REGISTER
! 83: register_term(pstricks)
! 84: #endif
! 85:
! 86: #ifdef TERM_PROTO
! 87: TERM_PUBLIC void PSTRICKS_options __PROTO((void));
! 88: TERM_PUBLIC void PSTRICKS_init __PROTO((void));
! 89: TERM_PUBLIC void PSTRICKS_graphics __PROTO((void));
! 90: TERM_PUBLIC void PSTRICKS_text __PROTO((void));
! 91: TERM_PUBLIC void PSTRICKS_linetype __PROTO((int linetype));
! 92: TERM_PUBLIC void PSTRICKS_move __PROTO((unsigned int x, unsigned int y));
! 93: TERM_PUBLIC void PSTRICKS_point __PROTO((unsigned int x, unsigned int y, int number));
! 94: TERM_PUBLIC void PSTRICKS_vector __PROTO((unsigned int ux, unsigned int uy));
! 95: TERM_PUBLIC void PSTRICKS_arrow __PROTO((unsigned int sx, unsigned int sy, unsigned int ex, unsigned int ey, TBOOLEAN head));
! 96: TERM_PUBLIC void PSTRICKS_put_text __PROTO((unsigned int x, unsigned int y, char str[]));
! 97: TERM_PUBLIC int PSTRICKS_justify_text __PROTO((enum JUSTIFY mode));
! 98: TERM_PUBLIC int PSTRICKS_text_angle __PROTO((int ang));
! 99: TERM_PUBLIC void PSTRICKS_reset __PROTO((void));
! 100:
! 101: #define PSTRICKS_XMAX 10000.0
! 102: #define PSTRICKS_YMAX 10000.0
! 103:
! 104: #define PSTRICKS_HTIC 150
! 105: #define PSTRICKS_VTIC 200
! 106: #define PSTRICKS_HCHAR 160
! 107: #define PSTRICKS_VCHAR 420
! 108: #endif /* TERM_PROTO */
! 109:
! 110: #ifndef TERM_PROTO_ONLY
! 111: #ifdef TERM_BODY
! 112: static void PSTRICKS_endline __PROTO((void));
! 113: static char *PSTRICKS_hack_text __PROTO((char s[]));
! 114:
! 115: static float PSTRICKS_xscale = 1.0;
! 116: static float PSTRICKS_yscale = 1.0;
! 117: static float PSTRICKS_posx;
! 118: static float PSTRICKS_posy;
! 119: enum JUSTIFY PSTRICKS_justify = LEFT;
! 120: static int PSTRICKS_angle = 0;
! 121:
! 122: #define PSTRICKS_TINY_DOT 0.00025 /* A tiny dot */
! 123:
! 124: /* POINTS */
! 125: #define PSTRICKS_POINT_TYPES 12 /* we supply more point types */
! 126: static char *PSTRICKS_points[] =
! 127: {
! 128: "\\PST@Diamond",
! 129: "\\PST@Plus",
! 130: "\\PST@Square",
! 131: "\\PST@Cross",
! 132: "\\PST@Circle",
! 133: "\\PST@Triangle",
! 134: "\\PST@Pentagon",
! 135: "\\PST@Filldiamond",
! 136: "\\PST@Fillsquare",
! 137: "\\PST@Filltriangle",
! 138: "\\PST@Fillcircle",
! 139: "\\PST@Fillpentagon"
! 140: };
! 141:
! 142: /* LINES */
! 143: #define PSTRICKS_NUMLINES 6 /* number of linetypes below */
! 144: static char *PSTRICKS_lines[] =
! 145: {
! 146: "\\PST@Border",
! 147: "\\PST@Axes",
! 148: "\\PST@Solid",
! 149: "\\PST@Dashed",
! 150: "\\PST@Dotted",
! 151: "\\PST@LongDash"
! 152: };
! 153:
! 154: /* current line type */
! 155: static int PSTRICKS_type;
! 156:
! 157: /* are we in the middle of a line */
! 158: static TBOOLEAN PSTRICKS_inline = FALSE;
! 159:
! 160: /* terminate any line in progress */
! 161: static void PSTRICKS_endline __PROTO((void));
! 162:
! 163: /* number of points in line so far */
! 164: static int PSTRICKS_linecount = 0;
! 165:
! 166: /* max value for linecount */
! 167: #define PSTRICKS_LINEMAX 100
! 168:
! 169: /*
! 170: * Handle options
! 171: */
! 172:
! 173: static int PST_hack_text = TRUE; /* Hack text on */
! 174: static int PST_unit_plot = FALSE; /* Unit-sized plot off */
! 175:
! 176: TERM_PUBLIC void PSTRICKS_options()
! 177: {
! 178: if (!END_OF_COMMAND) {
! 179: if (almost_equals(c_token, "no$hacktext")) {
! 180: PST_hack_text = FALSE;
! 181: c_token++;
! 182: } else if (almost_equals(c_token, "u$nit")) {
! 183: PST_unit_plot = TRUE;
! 184: c_token++;
! 185: }
! 186: }
! 187: }
! 188:
! 189: TERM_PUBLIC void PSTRICKS_init()
! 190: {
! 191: PSTRICKS_posx = PSTRICKS_posy = 0;
! 192: PSTRICKS_linetype(-1);
! 193: fputs("% GNUPLOT: LaTeX picture using PSTRICKS macros\n", gpoutfile);
! 194: }
! 195:
! 196:
! 197: TERM_PUBLIC void PSTRICKS_graphics()
! 198: {
! 199: fputs("\
! 200: % Define new PST objects, if not already defined\n\
! 201: \\ifx\\PSTloaded\\undefined\n\
! 202: \\def\\PSTloaded{t}\n\
! 203: \\psset{arrowsize=.01 3.2 1.4 .3}\n\
! 204: \\psset{dotsize=.01}\n\
! 205: \\catcode`@=11\n\n", gpoutfile);
! 206:
! 207: /* Define line type objects */
! 208: fputs("\
! 209: \\newpsobject{PST@Border}{psline}{linewidth=.0015,linestyle=solid}\n\
! 210: \\newpsobject{PST@Axes}{psline}{linewidth=.0015,linestyle=dotted,dotsep=.004}\n\
! 211: \\newpsobject{PST@Solid}{psline}{linewidth=.0015,linestyle=solid}\n\
! 212: \\newpsobject{PST@Dashed}{psline}{linewidth=.0015,linestyle=dashed,dash=.01 .01}\n\
! 213: \\newpsobject{PST@Dotted}{psline}{linewidth=.0025,linestyle=dotted,dotsep=.008}\n\
! 214: \\newpsobject{PST@LongDash}{psline}{linewidth=.0015,linestyle=dashed,dash=.02 .01}\n", gpoutfile);
! 215:
! 216: /* Define point objects */
! 217:
! 218: #ifdef OLD_PST
! 219: /* PSTricks version 0.91 had x and diamond dot types */
! 220: fputs("\
! 221: \\newpsobject(PST@Diamond}{psdots}{linewidth=.001,linestyle=solid,dotstyle=diamond}\n\
! 222: \\newpsobject(PST@Filldiamond}{psdots}{linewidth=.001,linestyle=solid,dotstyle=diamond*}\n\
! 223: \\newpsobject{PST@Cross}{psdots}{linewidth=.001,linestyle=solid,dotstyle=x}\n", gpoutfile);
! 224: #else
! 225: /* Newer versions use rotated plus and square to get the x and diamond dots */
! 226: fputs("\
! 227: \\newpsobject{PST@Diamond}{psdots}{linewidth=.001,linestyle=solid,dotstyle=square,dotangle=45}\n\
! 228: \\newpsobject{PST@Filldiamond}{psdots}{linewidth=.001,linestyle=solid,dotstyle=square*,dotangle=45}\n\
! 229: \\newpsobject{PST@Cross}{psdots}{linewidth=.001,linestyle=solid,dotstyle=+,dotangle=45}\n", gpoutfile);
! 230: #endif
! 231:
! 232: fputs("\
! 233: \\newpsobject{PST@Plus}{psdots}{linewidth=.001,linestyle=solid,dotstyle=+}\n\
! 234: \\newpsobject{PST@Square}{psdots}{linewidth=.001,linestyle=solid,dotstyle=square}\n\
! 235: \\newpsobject{PST@Circle}{psdots}{linewidth=.001,linestyle=solid,dotstyle=o}\n\
! 236: \\newpsobject{PST@Triangle}{psdots}{linewidth=.001,linestyle=solid,dotstyle=triangle}\n\
! 237: \\newpsobject{PST@Pentagon}{psdots}{linewidth=.001,linestyle=solid,dotstyle=pentagon}\n\
! 238: \\newpsobject{PST@Fillsquare}{psdots}{linewidth=.001,linestyle=solid,dotstyle=square*}\n\
! 239: \\newpsobject{PST@Fillcircle}{psdots}{linewidth=.001,linestyle=solid,dotstyle=*}\n\
! 240: \\newpsobject{PST@Filltriangle}{psdots}{linewidth=.001,linestyle=solid,dotstyle=triangle*}\n\
! 241: \\newpsobject{PST@Fillpentagon}{psdots}{linewidth=.001,linestyle=solid,dotstyle=pentagon*}\n", gpoutfile);
! 242:
! 243: /* Define arrow object */
! 244: fputs("\
! 245: \\newpsobject{PST@Arrow}{psline}{linewidth=.001,linestyle=solid}\n\
! 246: \\catcode`@=12\n\n\
! 247: \\fi\n", gpoutfile);
! 248:
! 249: /* Set the scaled plot size, if it's not a unit plot */
! 250: if (!PST_unit_plot) {
! 251: fprintf(gpoutfile, "\\psset{unit=%fin,xunit=%fin,yunit=%fin}\n",
! 252: 5.0 * PSTRICKS_xscale,
! 253: 5.0 * PSTRICKS_xscale,
! 254: 3.0 * PSTRICKS_yscale);
! 255: }
! 256: fputs("\
! 257: \\pspicture(0,0)(1,1)\n\
! 258: \\ifx\\nofigs\\undefined\n\
! 259: \\catcode`@=11\n\n", gpoutfile);
! 260: }
! 261:
! 262:
! 263: TERM_PUBLIC void PSTRICKS_text()
! 264: {
! 265: PSTRICKS_endline();
! 266: fputs("\
! 267: \\catcode`@=12\n\
! 268: \\fi\n\
! 269: \\endpspicture\n", gpoutfile);
! 270: }
! 271:
! 272:
! 273: TERM_PUBLIC void PSTRICKS_linetype(linetype)
! 274: int linetype;
! 275: {
! 276: PSTRICKS_endline();
! 277:
! 278: if (linetype >= PSTRICKS_NUMLINES - 2)
! 279: linetype %= (PSTRICKS_NUMLINES - 2);
! 280:
! 281: PSTRICKS_type = linetype;
! 282: }
! 283:
! 284:
! 285:
! 286: TERM_PUBLIC void PSTRICKS_move(x, y)
! 287: unsigned int x;
! 288: unsigned int y;
! 289: {
! 290: PSTRICKS_endline();
! 291:
! 292: PSTRICKS_posx = x / PSTRICKS_XMAX;
! 293: PSTRICKS_posy = y / PSTRICKS_YMAX;
! 294: }
! 295:
! 296:
! 297: TERM_PUBLIC void PSTRICKS_point(x, y, number) /* version of line_and_point */
! 298: unsigned x;
! 299: unsigned y;
! 300: int number;
! 301: {
! 302: PSTRICKS_move(x, y);
! 303:
! 304: /* Print the character defined by 'number'; number < 0 means
! 305: to use a dot, otherwise one of the defined points. */
! 306:
! 307: if (number < 0) {
! 308: fprintf(gpoutfile, "\\qdisk(%.4f,%.4f){%.4f}\n",
! 309: x / PSTRICKS_XMAX,
! 310: y / PSTRICKS_YMAX,
! 311: PSTRICKS_TINY_DOT);
! 312: } else {
! 313: fprintf(gpoutfile, "%s(%.4f,%.4f)\n",
! 314: PSTRICKS_points[number % PSTRICKS_POINT_TYPES],
! 315: x / PSTRICKS_XMAX,
! 316: y / PSTRICKS_YMAX);
! 317: }
! 318: }
! 319:
! 320:
! 321: TERM_PUBLIC void PSTRICKS_vector(ux, uy)
! 322: unsigned ux;
! 323: unsigned uy;
! 324: {
! 325: if (!PSTRICKS_inline) {
! 326: PSTRICKS_inline = TRUE;
! 327:
! 328: /* Start a new line. This depends on line type */
! 329: fprintf(gpoutfile, "%s(%.4f,%.4f)\n", PSTRICKS_lines[PSTRICKS_type + 2],
! 330: PSTRICKS_posx, PSTRICKS_posy);
! 331: PSTRICKS_linecount = 1;
! 332: } else {
! 333: /*
! 334: * Even though we are in middle of a path,
! 335: * we may want to start a new path command.
! 336: * If they are too long then latex will choke.
! 337: */
! 338: if (PSTRICKS_linecount++ >= PSTRICKS_LINEMAX) {
! 339: /* fprintf(gpoutfile, "\n"); */
! 340: fprintf(gpoutfile, "%s(%.4f,%.4f)\n", PSTRICKS_lines[PSTRICKS_type + 2],
! 341: PSTRICKS_posx, PSTRICKS_posy);
! 342: PSTRICKS_linecount = 1;
! 343: }
! 344: }
! 345: PSTRICKS_posx = ux / PSTRICKS_XMAX;
! 346: PSTRICKS_posy = uy / PSTRICKS_YMAX;
! 347: fprintf(gpoutfile, "(%.4f,%.4f)\n", PSTRICKS_posx, PSTRICKS_posy);
! 348: }
! 349:
! 350: static void PSTRICKS_endline()
! 351: {
! 352: if (PSTRICKS_inline) {
! 353: putc('\n', gpoutfile);
! 354: PSTRICKS_inline = FALSE;
! 355: }
! 356: }
! 357:
! 358:
! 359: TERM_PUBLIC void PSTRICKS_arrow(sx, sy, ex, ey, head)
! 360: unsigned int sx;
! 361: unsigned int sy;
! 362: unsigned int ex;
! 363: unsigned int ey;
! 364: TBOOLEAN head;
! 365: {
! 366: fprintf(gpoutfile, "\\PST@Arrow%s(%.4f,%.4f)(%.4f,%.4f)\n",
! 367: head ? "{->}" : "",
! 368: sx / PSTRICKS_XMAX,
! 369: sy / PSTRICKS_YMAX,
! 370: ex / PSTRICKS_XMAX,
! 371: ey / PSTRICKS_YMAX);
! 372:
! 373: PSTRICKS_posx = ex / PSTRICKS_XMAX;
! 374: PSTRICKS_posy = ey / PSTRICKS_YMAX;
! 375: }
! 376:
! 377: /*
! 378: * A really ugly hack!!!
! 379: *
! 380: * This function takes an input string and hacks it up. If the
! 381: * input string starts with a number, it converts the number into a
! 382: * TeX style number including exponential notation. Thus, if
! 383: * the input is the string "3.14159e3 is a number", then
! 384: * the output is "$3.14159\cdot 10^{3}$ is a number", so that TeX
! 385: * will produce something nice.
! 386: *
! 387: * This is basically meant for producing axis labels that look nice.
! 388: *
! 389: * What a hack!
! 390: */
! 391:
! 392:
! 393: static char *PSTRICKS_hack_text(s)
! 394: char s[];
! 395: {
! 396: double value;
! 397: char *ends;
! 398: static char hack[BUFSIZ];
! 399:
! 400: /*
! 401: * Does the string start with a number?
! 402: */
! 403:
! 404: value = strtod(s, &ends);
! 405:
! 406: if (s == ends) {
! 407: /*
! 408: * This doesn't start a number, so just copy the string over
! 409: */
! 410:
! 411: strcpy(hack, s);
! 412: } else {
! 413: char *ptr;
! 414:
! 415: /*
! 416: * We have a number! Check to see if the number
! 417: * is in scientific notation
! 418: */
! 419:
! 420: safe_strncpy(hack, s, ends - s);
! 421: /* hack[ends - s] = '\0'; */
! 422:
! 423: ptr = strchr(hack, 'e');
! 424: if (ptr == NULL) {
! 425: ptr = strchr(hack, 'E');
! 426: }
! 427: if (ptr != NULL) {
! 428: /*
! 429: * Exponential notation! Let's get the mantissa and exponent separately
! 430: */
! 431:
! 432: double man_val;
! 433: int expo_val;
! 434:
! 435: *ptr = NUL;
! 436:
! 437: man_val = atof(hack);
! 438: expo_val = atoi(ptr + 1);
! 439:
! 440: if (man_val == 0) {
! 441: sprintf(hack, "0");
! 442: } else if (man_val == 1) {
! 443: sprintf(hack, "$10^{%d}$", expo_val);
! 444: } else if (man_val == (int) man_val) {
! 445: if (expo_val == 1) {
! 446: sprintf(hack, "$%d$", (int) man_val);
! 447: } else {
! 448: sprintf(hack, "$%d \\times 10^{%d}$", (int) man_val, expo_val);
! 449: }
! 450: } else {
! 451: if (expo_val == 1) {
! 452: sprintf(hack, "$%f$", man_val);
! 453: } else {
! 454: sprintf(hack, "$%f \\times 10^{%d}$", man_val, expo_val);
! 455: }
! 456: }
! 457: }
! 458: /*
! 459: * Copy anything that's left of the string
! 460: */
! 461:
! 462: strcat(hack, ends);
! 463: }
! 464:
! 465: return hack;
! 466: }
! 467:
! 468: TERM_PUBLIC void PSTRICKS_put_text(x, y, str)
! 469: unsigned int x;
! 470: unsigned int y;
! 471: char str[];
! 472: {
! 473: PSTRICKS_endline();
! 474:
! 475: /* Skip this if the string is empty */
! 476:
! 477: if (strlen(str) > 0) {
! 478: fputs("\\rput", gpoutfile);
! 479:
! 480: /* Set justification */
! 481:
! 482: switch (PSTRICKS_justify) {
! 483: case LEFT:
! 484: fputs("[l]", gpoutfile);
! 485: break;
! 486: case CENTRE:
! 487: break;
! 488: case RIGHT:
! 489: fputs("[r]", gpoutfile);
! 490: break;
! 491: }
! 492:
! 493: /* Set text angle */
! 494:
! 495: switch (PSTRICKS_angle) {
! 496: case 0:
! 497: break;
! 498: case 1:
! 499: fputs("{L}", gpoutfile);
! 500: break;
! 501: }
! 502:
! 503: /* Set reference position and text */
! 504:
! 505: fprintf(gpoutfile, "(%.4f,%.4f)",
! 506: x / PSTRICKS_XMAX,
! 507: y / PSTRICKS_YMAX);
! 508: if (PST_hack_text) {
! 509: char *hack;
! 510:
! 511: /* Hack leading numbers to something nice for TeX */
! 512:
! 513: hack = PSTRICKS_hack_text(str);
! 514: fprintf(gpoutfile, "{%s}\n", hack);
! 515: } else {
! 516: fprintf(gpoutfile, "{%s}\n", str);
! 517: }
! 518: }
! 519: }
! 520:
! 521:
! 522:
! 523: TERM_PUBLIC int PSTRICKS_justify_text(mode)
! 524: enum JUSTIFY mode;
! 525: {
! 526: PSTRICKS_justify = mode;
! 527: return (TRUE);
! 528: }
! 529:
! 530: TERM_PUBLIC int PSTRICKS_text_angle(ang)
! 531: int ang;
! 532: {
! 533: PSTRICKS_angle = ang;
! 534: return (TRUE);
! 535: }
! 536:
! 537: TERM_PUBLIC void PSTRICKS_reset()
! 538: {
! 539: PSTRICKS_endline();
! 540: PSTRICKS_posx = PSTRICKS_posy = 0;
! 541: }
! 542:
! 543: #endif /* TERM_BODY */
! 544:
! 545: #ifdef TERM_TABLE
! 546:
! 547: TERM_TABLE_START(pstricks_driver)
! 548: "pstricks", "LaTeX picture environment with PSTricks macros",
! 549: PSTRICKS_XMAX, PSTRICKS_YMAX, PSTRICKS_VCHAR, PSTRICKS_HCHAR,
! 550: PSTRICKS_VTIC, PSTRICKS_HTIC, PSTRICKS_options, PSTRICKS_init, PSTRICKS_reset,
! 551: PSTRICKS_text, null_scale, PSTRICKS_graphics, PSTRICKS_move, PSTRICKS_vector,
! 552: PSTRICKS_linetype, PSTRICKS_put_text, PSTRICKS_text_angle,
! 553: PSTRICKS_justify_text, PSTRICKS_point, PSTRICKS_arrow, set_font_null
! 554: TERM_TABLE_END(pstricks_driver)
! 555:
! 556: #undef LAST_TERM
! 557: #define LAST_TERM pstricks_driver
! 558:
! 559: #endif /* TERM_TABLE */
! 560: #endif /* TERM_PROTO_ONLY */
! 561:
! 562: #ifdef TERM_HELP
! 563: START_HELP(pstricks)
! 564: "1 pstricks",
! 565: "?commands set terminal pstricks",
! 566: "?set terminal pstricks",
! 567: "?set term pstricks",
! 568: "?terminal pstricks",
! 569: "?term pstricks",
! 570: "?pstricks",
! 571: " The `pstricks` driver is intended for use with the \"pstricks.sty\" macro",
! 572: " package for LaTeX. It is an alternative to the `eepic` and `latex` drivers.",
! 573: " You need \"pstricks.sty\", and, of course, a printer that understands",
! 574: " PostScript, or a converter such as Ghostscript.",
! 575: "",
! 576: " PSTricks is available via anonymous ftp from the /pub directory at",
! 577: " Princeton.EDU. This driver definitely does not come close to using the full",
! 578: " capability of the PSTricks package.",
! 579: "",
! 580: " Syntax:",
! 581: " set terminal pstricks {hacktext | nohacktext} {unit | nounit}",
! 582: "",
! 583: " The first option invokes an ugly hack that gives nicer numbers; the second",
! 584: " has to do with plot scaling. The defaults are `hacktext` and `nounit`."
! 585: END_HELP(pstricks)
! 586: #endif /* TERM_HELP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pstricks.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term