--- /dev/null
+/* Hello, Emacs, this is -*-C-*-
+ * $Id: tpic.trm,v 1.21 2006/07/21 02:35:48 sfeam Exp $
+ */
+
+/* GNUPLOT - tpic.trm */
+
+/*[
+ * Copyright 1990 - 1993, 1998, 2004
+ *
+ * Permission to use, copy, and distribute this software and its
+ * documentation for any purpose with or without fee is hereby granted,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ *
+ * Permission to modify the software is granted, but not the right to
+ * distribute the complete modified source code. Modifications are to
+ * be distributed as patches to the released version. Permission to
+ * distribute binaries produced by compiling modified sources is granted,
+ * provided you
+ * 1. distribute the corresponding source modifications from the
+ * released version in the form of a patch file along with the binaries,
+ * 2. add special version identification to distinguish your version
+ * in addition to the base release version number,
+ * 3. provide your name and address as the primary contact for the
+ * support of your modified version, and
+ * 4. retain our contact information in regard to use of the base
+ * software.
+ * Permission to distribute the released version of the source code along
+ * with corresponding source modifications in the form of a patch file is
+ * granted with same provisions 2 through 4 for binary distributions.
+ *
+ * This software is provided "as is" without express or implied warranty
+ * to the extent permitted by applicable law.
+]*/
+
+/*
+ * This file is included by ../term.c.
+ *
+ * This terminal driver supports:
+ * The tpic \specials (version 2.2) for LaTeX.
+ *
+ * AUTHORS
+ * Oh-Yeah? 3 Sep. 1992 (closely following eepic.trm by David Kotz)
+ * A. Woo 5 Oct. 1992 (removed ansi prototypes for braindead compilers)
+ *
+ * send your comments or suggestions to (gnuplot-info@lists.sourceforge.net).
+ *
+ */
+/*
+ * This file contains the tpic terminal driver for use with LaTeX.
+ * This is an alternative to the latex and eepic drivers. You need
+ * a printer driver that supports the tpic \specials version 2.2.
+ *
+ * Comparison with the eepic driver (eepic.trm):
+ * Merits
+ * - More point and line types
+ * - Options to change point size, linewidth, dot & dash intervals
+ * - Dotted and dashed lines for high-sample-rate curves (but may
+ * depend on tpic (da & dt) implementation of your dvi driver :-)
+ * - Overlapped points made fancier by tpic shading facility
+ * - Optional comments for trimming figure margins
+ * - No need for epic and eepic macros
+ * Drawback
+ * - You cannot use eepicemu macro for non-tpic-support dvi drivers
+ *
+ * LATEX must also be defined.
+ */
+
+
+/* These parameters can be modified as you like, through options. Say
+ "set terminal tpic <pointsize> <linewidth> <interval>". <pointsize>
+ and <linewidth> are integers in milli-inches; <interval> is a float
+ in inches. If non-positive value is specified, the default (below)
+ is chosen.
+*/
+
+/*
+ * adapted to the new terminal layout by Stefan Bodewig (Dec. 1995)
+ */
+
+#include "driver.h"
+
+#ifdef TERM_REGISTER
+register_term(tpic)
+#endif
+
+#ifdef TERM_PROTO
+TERM_PUBLIC void TPIC_options __PROTO((void)); /* get size options */
+TERM_PUBLIC void TPIC_init __PROTO((void));
+TERM_PUBLIC void TPIC_reset __PROTO((void));
+TERM_PUBLIC void TPIC_text __PROTO((void));
+TERM_PUBLIC void TPIC_graphics __PROTO((void));
+TERM_PUBLIC void TPIC_move __PROTO((unsigned int x, unsigned int y));
+TERM_PUBLIC void TPIC_vector __PROTO((unsigned int ux, unsigned int uy));
+TERM_PUBLIC void TPIC_linetype __PROTO((int linetype));
+TERM_PUBLIC void TPIC_put_text __PROTO((unsigned int x, unsigned int y, const char *str)); /* ref point and text */
+TERM_PUBLIC int TPIC_text_angle __PROTO((int ang));
+TERM_PUBLIC int TPIC_justify_text __PROTO((enum JUSTIFY mode));
+TERM_PUBLIC void TPIC_point __PROTO((unsigned int x, unsigned int y, int number));
+TERM_PUBLIC void TPIC_arrow __PROTO((unsigned int sx, unsigned int sy, unsigned int ex, unsigned int ey, int head));
+
+/* tpic \specials unit in inches (1 milli-inch) */
+#define TPIC_UNIT 0.001
+
+/* 5 inches wide by 3 inches high (default) */
+#define TPIC_XMAX (unsigned int) (5 / TPIC_UNIT)
+#define TPIC_YMAX (unsigned int) (3 / TPIC_UNIT)
+#define TPIC_PTS_PER_UNIT (72.27 * TPIC_UNIT)
+#define TPIC_HTIC (unsigned int) ( 5.0 / TPIC_PTS_PER_UNIT) /* 5pt */
+#define TPIC_VTIC (unsigned int) ( 5.0 / TPIC_PTS_PER_UNIT) /* 5pt */
+#define TPIC_HCHAR (unsigned int) ( 5.3 / TPIC_PTS_PER_UNIT) /* 5.3pt */
+#define TPIC_VCHAR (unsigned int) (11.0 / TPIC_PTS_PER_UNIT) /* 11pt */
+#endif /* TERM_PROTO */
+
+#ifndef TERM_PROTO_ONLY
+#ifdef TERM_BODY
+static int tpic_pointsize = 40; /* min point radius (in milli-inches) */
+static int tpic_linewidth = 6; /* min line thickness (in milli-inches) */
+static double tpic_interval = 0.1; /* min dot & dash intervals (in inches) */
+
+/* ARROWS: same code as for LATEX */
+/* figure out the best arrow. in latex.trm */
+static void best_latex_arrow __PROTO((int sx, int sy, int ex, int ey, int who, int head));
+
+/* all prototypes ... */
+static void tpic_startline __PROTO((void));
+static void tpic_endline __PROTO((void));
+static void tpic_pushpath __PROTO((unsigned int x, unsigned int y));
+static void tpic_scanpath __PROTO((void));
+static void tpic_diamond __PROTO((int size));
+static void tpic_plus __PROTO((int size));
+static void tpic_box __PROTO((int size));
+static void tpic_times __PROTO((int size));
+static void tpic_triangle __PROTO((int size));
+static void tpic_star __PROTO((int size));
+static void tpic_hexagon __PROTO((int size));
+static void tpic_circle __PROTO((int size));
+static void tpic_doublecircle __PROTO((int size));
+static void tpic_vercircle __PROTO((int size)); /* circle with | */
+static void tpic_horcircle __PROTO((int size)); /* circle with - */
+static void tpic_pluscircle __PROTO((int size)); /* circle with + */
+static void tpic_timescircle __PROTO((int size)); /* circle with times */
+static void tpic_starcircle __PROTO((int size)); /* circle with star */
+static void tpic_dotcircle __PROTO((int size)); /* circle with dot (black circle) */
+static void tpic_diamondcircle __PROTO((int size)); /* circle with black diamond */
+static void tpic_boxcircle __PROTO((int size)); /* circle with black box */
+static void tpic_trianglecircle __PROTO((int size)); /* circle with black triangle */
+static void tpic_hexagoncircle __PROTO((int size)); /* circle with black hexagon */
+static void tpic_plustimescircle __PROTO((int size)); /* no more idea ... with plus & times */
+static void tpic_abspath __PROTO((unsigned int x, unsigned int y)); /* absolute coord */
+static void tpic_path __PROTO((int x, int y));
+static void tpic_flush __PROTO((void));
+static void tpic_arc __PROTO((int radius)); /* actually, draw a full circle */
+static void tpic_shade __PROTO((double grayscale));
+static void tpic_pen __PROTO((int thickness));
+static void tpic_dottedflush __PROTO((double interval));
+static void tpic_dashedflush __PROTO((double interval));
+
+typedef enum {
+ tpic_none, tpic_white, tpic_gray, tpic_black
+} tpic_shadestyle;
+typedef enum {
+ tpic_nosize, tpic_small, tpic_medium, tpic_large
+} tpic_size;
+typedef void (*tpic_function) __PROTO((int size));
+
+typedef struct {
+ tpic_shadestyle shadestyle;
+ tpic_size size;
+ tpic_function function;
+} tpic_point_info;
+
+/* POINTS */
+static /*GPFAR */ tpic_point_info GPFAR tpic_point[] =
+{
+ {tpic_white, tpic_medium, tpic_diamond},
+ {tpic_none, tpic_medium, tpic_plus},
+ {tpic_white, tpic_medium, tpic_box},
+ {tpic_none, tpic_medium, tpic_times},
+ {tpic_white, tpic_medium, tpic_triangle},
+ {tpic_none, tpic_medium, tpic_star},
+ {tpic_white, tpic_small, tpic_circle},
+ {tpic_white, tpic_medium, tpic_circle},
+ {tpic_white, tpic_large, tpic_circle},
+ {tpic_black, tpic_small, tpic_circle},
+ {tpic_black, tpic_medium, tpic_circle},
+ {tpic_black, tpic_large, tpic_circle},
+ {tpic_black, tpic_medium, tpic_diamond},
+ {tpic_black, tpic_medium, tpic_box},
+ {tpic_black, tpic_medium, tpic_triangle},
+ {tpic_white, tpic_medium, tpic_hexagon},
+ {tpic_black, tpic_medium, tpic_hexagon},
+ {tpic_white, tpic_medium, tpic_doublecircle},
+ {tpic_white, tpic_medium, tpic_vercircle},
+ {tpic_white, tpic_medium, tpic_horcircle},
+ {tpic_white, tpic_medium, tpic_pluscircle},
+ {tpic_white, tpic_medium, tpic_timescircle},
+ {tpic_white, tpic_medium, tpic_starcircle},
+ {tpic_black, tpic_medium, tpic_doublecircle},
+ {tpic_white, tpic_medium, tpic_dotcircle},
+ {tpic_white, tpic_medium, tpic_diamondcircle},
+ {tpic_white, tpic_medium, tpic_boxcircle},
+ {tpic_white, tpic_medium, tpic_trianglecircle},
+ {tpic_white, tpic_medium, tpic_hexagoncircle},
+ {tpic_white, tpic_medium, tpic_plustimescircle}
+};
+
+typedef enum {
+ tpic_solid, tpic_dotted, tpic_dashed,
+ tpic_dashed_sdot, tpic_dashed_ddot
+} tpic_linestyle;
+typedef struct {
+ tpic_size thickness, interval;
+ tpic_linestyle linestyle;
+} tpic_line_info;
+
+/* LINES */
+static /*GPFAR */ tpic_line_info GPFAR tpic_line[] =
+{
+ {tpic_medium, tpic_nosize, tpic_solid}, /* -2 border */
+ {tpic_small, tpic_small, tpic_dashed}, /* -1 axes */
+ {tpic_small, tpic_nosize, tpic_solid},
+ {tpic_medium, tpic_nosize, tpic_solid},
+ {tpic_large, tpic_nosize, tpic_solid},
+ {tpic_small, tpic_small, tpic_dotted},
+ {tpic_medium, tpic_small, tpic_dotted},
+ {tpic_large, tpic_small, tpic_dotted},
+ {tpic_small, tpic_small, tpic_dashed},
+ {tpic_medium, tpic_small, tpic_dashed},
+ {tpic_large, tpic_small, tpic_dashed},
+ {tpic_small, tpic_small, tpic_dashed_sdot}, /* dash with single dots */
+ {tpic_medium, tpic_small, tpic_dashed_sdot},
+ {tpic_large, tpic_small, tpic_dashed_sdot},
+ {tpic_small, tpic_small, tpic_dashed_ddot}, /* dash with double dots */
+ {tpic_medium, tpic_small, tpic_dashed_ddot},
+ {tpic_large, tpic_small, tpic_dashed_ddot},
+ {tpic_small, tpic_medium, tpic_dotted},
+ {tpic_medium, tpic_medium, tpic_dotted},
+ {tpic_large, tpic_medium, tpic_dotted},
+ {tpic_small, tpic_medium, tpic_dashed},
+ {tpic_medium, tpic_medium, tpic_dashed},
+ {tpic_large, tpic_medium, tpic_dashed},
+ {tpic_small, tpic_medium, tpic_dashed_sdot},
+ {tpic_medium, tpic_medium, tpic_dashed_sdot},
+ {tpic_large, tpic_medium, tpic_dashed_sdot},
+ {tpic_small, tpic_medium, tpic_dashed_ddot},
+ {tpic_medium, tpic_medium, tpic_dashed_ddot},
+ {tpic_large, tpic_medium, tpic_dashed_ddot},
+ {tpic_small, tpic_large, tpic_dotted},
+ {tpic_medium, tpic_large, tpic_dotted},
+ {tpic_large, tpic_large, tpic_dotted},
+ {tpic_small, tpic_large, tpic_dashed},
+ {tpic_medium, tpic_large, tpic_dashed},
+ {tpic_large, tpic_large, tpic_dashed},
+ {tpic_small, tpic_large, tpic_dashed_sdot},
+ {tpic_medium, tpic_large, tpic_dashed_sdot},
+ {tpic_large, tpic_large, tpic_dashed_sdot},
+ {tpic_small, tpic_large, tpic_dashed_ddot},
+ {tpic_medium, tpic_large, tpic_dashed_ddot},
+ {tpic_large, tpic_large, tpic_dashed_ddot}
+};
+
+TERM_PUBLIC void
+TPIC_options()
+{ /* get size options */
+ struct value a;
+ int ptsize, linewidth;
+ double interval;
+
+ if (!END_OF_COMMAND) {
+ ptsize = (int) real(const_express(&a));
+ if (ptsize > 0)
+ tpic_pointsize = ptsize;
+ }
+ if (!END_OF_COMMAND) {
+ linewidth = (int) real(const_express(&a));
+ if (linewidth > 0)
+ tpic_linewidth = linewidth;
+ }
+ if (!END_OF_COMMAND) {
+ interval = (double) real(const_express(&a));
+ if (interval > 0)
+ tpic_interval = interval;
+ }
+ sprintf(term_options, "%d %d %f", tpic_pointsize, tpic_linewidth,
+ tpic_interval);
+}
+
+static unsigned int tpic_posx; /* current position */
+static unsigned int tpic_posy;
+static int tpic_point_types;
+static int tpic_numlines;
+
+TERM_PUBLIC void
+TPIC_init()
+{
+ static char GPFAR tpic1[] = "\
+%% GNUPLOT: LaTeX picture using tpic \\specials\n\
+%% with %d point types and %d line types\n\
+%% Options: pointsize = %d, linewidth = %d, interval = %f\n\
+%% To change above options, say:\n\
+%% set terminal tpic pointsize_value linewidth_value interval_value\n\
+%% (pointsize and linewidth - integers in milli-inches.\n\
+%% interval - a float in inches. If zero is specified, \n\
+%% the default value is chosen.)\n\
+\\setlength{\\unitlength}{%fin}%%\n";
+ tpic_point_types = sizeof(tpic_point) / sizeof(tpic_point[0]);
+ tpic_numlines = sizeof(tpic_line) / sizeof(tpic_line[0]);
+
+ tpic_posx = tpic_posy = 0;
+ TPIC_linetype(-1);
+ fprintf(gpoutfile, tpic1,
+ tpic_point_types, tpic_numlines - 2,
+ tpic_pointsize, tpic_linewidth, tpic_interval,
+ TPIC_UNIT);
+}
+
+TERM_PUBLIC void
+TPIC_reset()
+{
+ tpic_endline();
+ tpic_posx = tpic_posy = 0;
+}
+
+TERM_PUBLIC void
+TPIC_text()
+{
+ tpic_endline();
+ fputs("\\end{picture}\n", gpoutfile);
+}
+
+TERM_PUBLIC void
+TPIC_graphics()
+{
+ register struct termentry *t = term;
+ int left, right, top, bottom; /* margins */
+ static char GPFAR begin[] = "%s\\begin{picture}(%d,%d)(%d,%d)%% %s\n";
+
+ fprintf(gpoutfile, begin, "", t->xmax, t->ymax, 0, 0, "");
+
+ /* the following is dependent on boundary() function in graphics.c */
+ left = TPIC_HCHAR * 12;
+ right = TPIC_HCHAR * 2 + TPIC_HTIC;
+ bottom = TPIC_VCHAR * 7 / 2 + 1;
+ top = TPIC_VCHAR * 5 / 2 - 1;
+ fprintf(gpoutfile, begin, "%% ", t->xmax - left, t->ymax, left, 0,
+ "trim left margin");
+ fprintf(gpoutfile, begin, "%% ", t->xmax - right, t->ymax, 0, 0,
+ "trim right margin");
+ fprintf(gpoutfile, begin, "%% ", t->xmax - left - right, t->ymax, left, 0,
+ "trim left & right margins");
+ fprintf(gpoutfile, begin, "%% ", t->xmax, t->ymax - top, 0, 0,
+ "trim top margin");
+ fprintf(gpoutfile, begin, "%% ", t->xmax, t->ymax - bottom, 0, bottom,
+ "trim bottom margin");
+ fprintf(gpoutfile, begin, "%% ", t->xmax, t->ymax - top - bottom, 0, bottom,
+ "trim top & bottom margins");
+
+ fputs("\\footnotesize%\n", gpoutfile);
+}
+
+TERM_PUBLIC void
+TPIC_move(unsigned int x, unsigned int y)
+{
+ tpic_endline();
+ tpic_posx = x;
+ tpic_posy = y;
+}
+
+#define TPIC_LINEMAX 100 /* max value for linecount */
+static TBOOLEAN tpic_inline = FALSE; /* are we in the middle of a line */
+static int tpic_linecount = 0; /* number of points in line so far */
+
+TERM_PUBLIC void
+TPIC_vector(unsigned int ux, unsigned int uy)
+{
+ if (!tpic_inline) {
+ tpic_startline();
+ } else if (tpic_linecount >= TPIC_LINEMAX) {
+ /* Even though we are in middle of a path, we may start a new path
+ command once in a while; if they are too long, latex will choke. */
+ tpic_endline();
+ tpic_startline();
+ }
+ tpic_pushpath(ux, uy);
+ tpic_posx = ux;
+ tpic_posy = uy;
+}
+
+static int tpic_linetype; /* current line type */
+
+static void
+tpic_startline()
+{ /* private */
+ int thickness = 1;
+
+ tpic_inline = TRUE;
+ switch (tpic_line[tpic_linetype + 2].thickness) {
+ case tpic_small:
+ thickness = tpic_linewidth;
+ break;
+ case tpic_medium:
+ thickness = (int) (tpic_linewidth * 3);
+ break;
+ case tpic_large:
+ thickness = (int) (tpic_linewidth * 5);
+ break;
+ default:
+ break;
+ }
+ tpic_pen(thickness);
+ tpic_linecount = 0;
+ tpic_pushpath(tpic_posx, tpic_posy);
+ return;
+}
+
+static void
+tpic_endline()
+{ /* private */
+ double interval = 1;
+
+ if (tpic_inline) {
+ tpic_scanpath(); /* draw actually */
+ switch (tpic_line[tpic_linetype + 2].interval) {
+ case tpic_small:
+ interval = tpic_interval;
+ break;
+ case tpic_medium:
+ interval = tpic_interval * 2;
+ break;
+ case tpic_large:
+ interval = tpic_interval * 3;
+ break;
+ case tpic_nosize:
+ break;
+ }
+ switch (tpic_line[tpic_linetype + 2].linestyle) {
+ case tpic_solid:
+ tpic_flush();
+ break;
+ case tpic_dotted:
+ tpic_dottedflush(interval);
+ break;
+ case tpic_dashed:
+ tpic_dashedflush(interval);
+ break;
+ case tpic_dashed_sdot: /* dashed with single dots in between */
+ tpic_dashedflush(interval);
+ tpic_scanpath(); /* draw again */
+ tpic_dottedflush(interval / 2);
+ break;
+ case tpic_dashed_ddot: /* dashed with double dots in between */
+ tpic_dashedflush(interval);
+ tpic_scanpath(); /* draw again */
+ tpic_dottedflush(interval / 3);
+ break;
+ }
+ tpic_inline = FALSE;
+ }
+ return;
+}
+
+/* private: stack functions */
+static unsigned int pathpoint[TPIC_LINEMAX][2]; /* point stack */
+
+static void
+tpic_pushpath(unsigned int x, unsigned int y)
+{
+ if (tpic_linecount < TPIC_LINEMAX) {
+ pathpoint[tpic_linecount][0] = x;
+ pathpoint[tpic_linecount][1] = y;
+ tpic_linecount++;
+ }
+ return;
+}
+
+static void
+tpic_scanpath()
+{
+ int i;
+
+ for (i = 0; i < tpic_linecount; i++)
+ tpic_abspath(pathpoint[i][0], pathpoint[i][1]);
+ return;
+}
+
+TERM_PUBLIC void
+TPIC_linetype(int linetype)
+{
+ tpic_endline();
+ if (linetype < -2)
+ linetype = LT_BLACK;
+ if (linetype >= tpic_numlines - 2)
+ linetype %= (tpic_numlines - 2);
+ tpic_linetype = linetype;
+}
+
+static int tpic_angle = 0; /* 0 = horizontal, 1 = vertical */
+static enum JUSTIFY tpic_justify = LEFT;
+
+TERM_PUBLIC void
+TPIC_put_text(unsigned int x, unsigned int y, const char *str)
+{
+ char *justify = NULL;
+
+ tpic_endline();
+ fprintf(gpoutfile, "\\put(%d,%d)", x, y);
+
+ if ((str[0] == '{') || (str[0] == '[')) {
+ fprintf(gpoutfile, "{\\makebox(0,0)%s}\n", str);
+ } else
+ switch (tpic_angle) {
+ case 0: /* horizontal */
+ switch (tpic_justify) {
+ case LEFT:
+ justify = "[l]";
+ break;
+ case CENTRE:
+ justify = "";
+ break;
+ case RIGHT:
+ justify = "[r]";
+ break;
+ }
+ fprintf(gpoutfile, "{\\makebox(0,0)%s{%s}}\n", justify, str);
+ break;
+ case 1: /* vertical */
+ /* we can't really write text vertically, but will put the ylabel
+ centred at the left of the plot, and then we'll make a \shortstack */
+ switch (tpic_justify) {
+ case LEFT:
+ justify = "[lb]";
+ break;
+ case CENTRE:
+ justify = "[l]";
+ break;
+ case RIGHT:
+ justify = "[lt]";
+ break;
+ }
+ fprintf(gpoutfile, "{\\makebox(0,0)%s{\\shortstack{%s}}}\n",
+ justify, str);
+ break;
+ }
+}
+
+TERM_PUBLIC int
+TPIC_text_angle(int ang)
+{
+ tpic_angle = (ang ? 1 : 0);
+ return (TRUE);
+}
+
+TERM_PUBLIC int
+TPIC_justify_text(enum JUSTIFY mode)
+{
+ tpic_justify = mode;
+ return (TRUE);
+}
+
+TERM_PUBLIC void
+TPIC_point(unsigned int x, unsigned int y, int number)
+{
+ int size = 0;
+
+ TPIC_move(x, y);
+
+ /* Print the character defined by 'number'; number < 0 means
+ to use a dot, otherwise one of the defined points. */
+
+ fprintf(gpoutfile, "\\put(%d,%d){", x, y); /* start putting */
+
+ if (number < 0) {
+ fputs("\\rule{.1pt}{.1pt}", gpoutfile); /* tiny dot */
+ } else {
+ number %= tpic_point_types;
+ switch (tpic_point[number].shadestyle) {
+ case tpic_white:
+ tpic_pen(tpic_linewidth); /* set it thin */
+ tpic_shade(0.0);
+ break;
+ case tpic_gray:
+ tpic_pen(tpic_linewidth);
+ tpic_shade(0.5);
+ break;
+ case tpic_black:
+ tpic_pen(tpic_linewidth);
+ tpic_shade(1.0);
+ break;
+ case tpic_none:
+ tpic_pen(tpic_linewidth * 3); /* set it thick */
+ break;
+ }
+ switch (tpic_point[number].size) {
+ case tpic_small:
+ size = tpic_pointsize;
+ break;
+ case tpic_medium:
+ size = (int) (tpic_pointsize * 1.4142);
+ break;
+ case tpic_large:
+ size = (int) (tpic_pointsize * 2.0);
+ break;
+ default:
+ break;
+ }
+ (tpic_point[number].function) (size);
+ }
+
+ fputs("}%%\n", gpoutfile); /* end putting */
+}
+
+TERM_PUBLIC void
+TPIC_arrow(
+ unsigned int sx, unsigned int sy,
+ unsigned int ex, unsigned int ey,
+ int head)
+{
+ best_latex_arrow(sx, sy, ex, ey, 1, head); /* call latex routine */
+ tpic_posx = ex;
+ tpic_posy = ey;
+}
+
+/* private: draw points with tpic commands */
+
+static void
+tpic_diamond(int size)
+{
+ size = (int) (size * 1.4142); /* spread by sqrt(2) */
+
+ tpic_path(0, size);
+ tpic_path(-size, 0);
+ tpic_path(0, -size);
+ tpic_path(size, 0);
+ tpic_path(0, size);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_plus(int size)
+{
+ tpic_path(0, size);
+ tpic_path(0, -size);
+ tpic_flush();
+ tpic_path(size, 0);
+ tpic_path(-size, 0);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_box(int size)
+{
+ tpic_path(size, size);
+ tpic_path(-size, size);
+ tpic_path(-size, -size);
+ tpic_path(size, -size);
+ tpic_path(size, size);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_times(int size)
+{
+ size = (int) (size / 1.4142); /* reduce by sqrt(2) */
+
+ tpic_path(size, size);
+ tpic_path(-size, -size);
+ tpic_flush();
+ tpic_path(size, -size);
+ tpic_path(-size, size);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_triangle(int size)
+{
+ int x;
+
+ size = (int) (size / 1.6119); /* reduce by sqrt(3 * sqrt(3) / 2) */
+ x = (int) (size * 1.7321);
+
+ tpic_path(0, -size * 2);
+ tpic_path(-x, size);
+ tpic_path(x, size);
+ tpic_path(0, -size * 2);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_star(int size)
+{
+ int x;
+
+ size = (int) (size / 2); /* reduce by 2 */
+ x = (int) (size * 1.7321);
+
+ tpic_path(0, size * 2);
+ tpic_path(0, -size * 2);
+ tpic_flush();
+ tpic_path(x, size);
+ tpic_path(-x, -size);
+ tpic_flush();
+ tpic_path(x, -size);
+ tpic_path(-x, size);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_hexagon(int size)
+{
+ int x;
+
+ size = (int) (size / 2); /* reduce by 2 */
+ x = (int) (size * 1.7321);
+
+ tpic_path(0, size * 2);
+ tpic_path(-x, size);
+ tpic_path(-x, -size);
+ tpic_path(0, -size * 2);
+ tpic_path(x, -size);
+ tpic_path(x, size);
+ tpic_path(0, size * 2);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_circle(int size)
+{
+ tpic_arc(size);
+ return;
+}
+
+static void
+tpic_doublecircle(int size)
+{
+ tpic_arc(size);
+ tpic_shade(0.0);
+ tpic_arc(size / 2);
+ return;
+}
+
+static void
+tpic_vercircle(int size) /* circle with | */
+{
+ tpic_arc(size);
+ tpic_path(0, size);
+ tpic_path(0, -size);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_horcircle(int size) /* circle with - */
+{
+ tpic_arc(size);
+ tpic_path(size, 0);
+ tpic_path(-size, 0);
+ tpic_flush();
+ return;
+}
+
+static void
+tpic_pluscircle(int size) /* circle with + */
+{
+ tpic_arc(size);
+ tpic_plus(size);
+ return;
+}
+
+static void
+tpic_timescircle(int size) /* circle with times */
+{
+ tpic_arc(size);
+ tpic_times(size);
+ return;
+}
+
+static void
+tpic_starcircle(int size) /* circle with star */
+{
+ tpic_arc(size);
+ tpic_star(size);
+ return;
+}
+
+static void
+tpic_dotcircle(int size) /* circle with dot (black circle) */
+{
+ tpic_arc(size);
+ tpic_shade(1.0);
+ tpic_arc(size / 2);
+ return;
+}
+
+static void
+tpic_diamondcircle(int size) /* not enough? circle with black diamond */
+{
+ tpic_arc(size);
+ tpic_shade(1.0);
+ tpic_diamond((int) (size / 1.5));
+ return;
+}
+
+static void
+tpic_boxcircle(int size) /* need more? circle with black box */
+{
+ tpic_arc(size);
+ tpic_shade(1.0);
+ tpic_box((int) (size / 1.5));
+ return;
+}
+
+static void
+tpic_trianglecircle(int size) /* circle with black triangle */
+{
+ tpic_arc(size);
+ tpic_shade(1.0);
+ tpic_triangle((int) (size / 1.5));
+ return;
+}
+
+static void
+tpic_hexagoncircle(int size) /* how about circle with black hexagon? */
+{
+ tpic_arc(size);
+ tpic_shade(1.0);
+ tpic_hexagon((int) (size / 1.2));
+ return;
+}
+
+static void
+tpic_plustimescircle(int size) /* no more idea ... with plus & times */
+{
+ tpic_arc(size);
+ tpic_plus(size);
+ tpic_times(size);
+ return;
+}
+
+/* private: draw lines */
+
+static void
+tpic_abspath(unsigned int x, unsigned int y)
+{
+ tpic_path(x, -y);
+ fputs("%\n", gpoutfile);
+ return;
+}
+
+/* private: tpic primitive functions */
+
+static void
+tpic_path(int x, int y)
+{
+ fprintf(gpoutfile, "\\special{pa %d %d}", x, y);
+ return;
+}
+
+static void
+tpic_flush()
+{
+ fputs("\\special{fp}%\n", gpoutfile);
+ return;
+}
+
+static void
+tpic_arc(int radius)
+{
+ /* actually, draw a full circle */
+ fprintf(gpoutfile, "\\special{ar 0 0 %d %d 0 7}", radius, radius);
+ return;
+}
+
+static void
+tpic_shade(double grayscale)
+{
+ fprintf(gpoutfile, "\\special{sh %f}", grayscale);
+ return;
+}
+
+static void
+tpic_pen(int thickness)
+{
+ fprintf(gpoutfile, "\\special{pn %d}", thickness);
+ return;
+}
+
+static void
+tpic_dottedflush(double interval)
+{
+ fprintf(gpoutfile, "\\special{dt %f}%%\n", interval);
+ return;
+}
+
+static void
+tpic_dashedflush(double interval)
+{
+ fprintf(gpoutfile, "\\special{da %f}%%\n", interval);
+ return;
+}
+
+#endif /* TERM_BODY */
+
+#ifdef TERM_TABLE
+
+TERM_TABLE_START(tpic_driver)
+ "tpic", "TPIC -- LaTeX picture environment with tpic \\specials",
+ TPIC_XMAX, TPIC_YMAX, TPIC_VCHAR, TPIC_HCHAR,
+ TPIC_VTIC, TPIC_HTIC, TPIC_options, TPIC_init, TPIC_reset,
+ TPIC_text, null_scale, TPIC_graphics, TPIC_move, TPIC_vector,
+ TPIC_linetype, TPIC_put_text, TPIC_text_angle,
+ TPIC_justify_text, TPIC_point, TPIC_arrow, set_font_null
+TERM_TABLE_END(tpic_driver)
+
+#undef LAST_TERM
+#define LAST_TERM tpic_driver
+
+#endif /* TERM_TABLE */
+#endif /* TERM_PROTO_ONLY */
+
+#ifdef TERM_HELP
+START_HELP(tpic)
+"1 tpic",
+"?commands set terminal tpic",
+"?set terminal tpic",
+"?set term tpic",
+"?terminal tpic",
+"?term tpic",
+"?tpic",
+" The `tpic` terminal driver supports the LaTeX picture environment with tpic",
+" \\specials. It is an alternative to the `latex` and `eepic` terminal drivers.",
+" Options are the point size, line width, and dot-dash interval.",
+"",
+" Syntax:",
+" set terminal tpic <pointsize> <linewidth> <interval>",
+"",
+" where `pointsize` and `linewidth` are integers in milli-inches and `interval`",
+" is a float in inches. If a non-positive value is specified, the default is",
+" chosen: pointsize = 40, linewidth = 6, interval = 0.1.",
+"",
+" All drivers for LaTeX offer a special way of controlling text positioning:",
+" If any text string begins with '{', you also need to include a '}' at the",
+" end of the text, and the whole text will be centered both horizontally",
+" and vertically by LaTeX. --- If the text string begins with '[', you need",
+" to continue it with: a position specification (up to two out of t,b,l,r),",
+" ']{', the text itself, and finally, '}'. The text itself may be anything",
+" LaTeX can typeset as an LR-box. \\rule{}{}'s may help for best positioning.",
+"",
+" Examples:",
+" About label positioning:",
+" Use gnuplot defaults (mostly sensible, but sometimes not really best):",
+" set title '\\LaTeX\\ -- $ \\gamma $'",
+" Force centering both horizontally and vertically:",
+" set label '{\\LaTeX\\ -- $ \\gamma $}' at 0,0",
+" Specify own positioning (top here):",
+" set xlabel '[t]{\\LaTeX\\ -- $ \\gamma $}'",
+" The other label -- account for long ticlabels:",
+" set ylabel '[r]{\\LaTeX\\ -- $ \\gamma $\\rule{7mm}{0pt}}'"
+END_HELP(tpic)
+#endif /* TERM_TABLE */
projects / gnuplot / blobdiff