home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume24 / gnuplot3 / part17 < prev    next >
Text File  |  1991-10-27  |  49KB  |  1,741 lines
  1. Newsgroups: comp.sources.misc
  2. From: gershon%gr@cs.utah.edu (Elber Gershon)
  3. Subject:  v24i039:  gnuplot3 - interactive function plotting utility, Part17/26
  4. Message-ID: <1991Oct28.002324.12536@sparky.imd.sterling.com>
  5. X-Md4-Signature: 2e7b599a6d9e532057d6defc66706ba1
  6. Date: Mon, 28 Oct 1991 00:23:24 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: gershon%gr@cs.utah.edu (Elber Gershon)
  10. Posting-number: Volume 24, Issue 39
  11. Archive-name: gnuplot3/part17
  12. Environment: UNIX, MS-DOS, VMS
  13. Supersedes: gnuplot2: Volume 11, Issue 65-79
  14.  
  15. #!/bin/sh
  16. # this is Part.17 (part 17 of a multipart archive)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file gnuplot/term/iris4d.trm continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 17; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping gnuplot/term/iris4d.trm'
  34. else
  35. echo 'x - continuing file gnuplot/term/iris4d.trm'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'gnuplot/term/iris4d.trm' &&
  37. X  
  38. X  return;
  39. }
  40. X
  41. IRIS4D_text()
  42. {
  43. X  return; /* enter text from another window!!! */
  44. }
  45. X
  46. IRIS4D_linetype(linetype)
  47. int linetype;
  48. {
  49. X  static int pen_color_24[11] =
  50. X    {
  51. X      IRIS4D_BLACK,        /* reserved for border and numbers */
  52. X      IRIS4D_MAGENTA,        /* reserved for axis traces */
  53. X      IRIS4D_LIGHTCYAN,
  54. X      IRIS4D_RED,
  55. X      IRIS4D_GREEN,
  56. X      IRIS4D_LIGHTMAGENTA,
  57. X      IRIS4D_YELLOW,
  58. X      IRIS4D_LIGHTRED,
  59. X      IRIS4D_LIGHTGREEN,
  60. X      IRIS4D_CYAN,
  61. X      IRIS4D_BROWN,
  62. X    };
  63. X  static int pen_color[8] = {0 ,1, 4, 5, 6, 1, 2, 4};
  64. X
  65. X  if (iris24bits)
  66. X  {
  67. X    int pencolor = pen_color_24[linetype < 0 ? linetype + 2 : linetype % 9 + 2];
  68. X
  69. X    RGBcolor(colors24bits[pencolor][0],
  70. X         colors24bits[pencolor][1],
  71. X         colors24bits[pencolor][2]);
  72. X    /* Make all lines solid (linestyle 0) upto to the ninth. If more than
  73. X     * 9 colors are needed, start to use the different line styles (1 to 8).
  74. X     */
  75. X    setlinestyle(linetype < 9 ? 0 : (linetype + 2) % 8 + 1);
  76. X  }
  77. X  else
  78. X  {
  79. X    linetype = linetype % 8;
  80. X    color((Colorindex) pen_color[linetype]);
  81. X    setlinestyle(linetype);
  82. X  }
  83. X  return;
  84. }
  85. X
  86. IRIS4D_move(x, y)
  87. unsigned int x, y;
  88. {
  89. X  move2i(x, y);
  90. X  return;
  91. }
  92. X
  93. IRIS4D_cmove(x, y)
  94. unsigned int x, y;
  95. {
  96. X  cmov2i(x, y);
  97. X  return;
  98. }
  99. X
  100. IRIS4D_vector(x, y)
  101. unsigned x, y;
  102. {
  103. X  draw2i(x, y);
  104. X  return;
  105. }
  106. X
  107. X
  108. IRIS4D_put_text(x,y,str)
  109. int x, y;
  110. char *str;
  111. {
  112. X  IRIS4D_cmove(x,y - IRIS4D_VCHAR/2);
  113. X  charstr(str);
  114. X  return;
  115. }
  116. X
  117. X
  118. IRIS4D_reset()
  119. {
  120. X  return;
  121. }
  122. X
  123. SHAR_EOF
  124. echo 'File gnuplot/term/iris4d.trm is complete' &&
  125. chmod 0644 gnuplot/term/iris4d.trm ||
  126. echo 'restore of gnuplot/term/iris4d.trm failed'
  127. Wc_c="`wc -c < 'gnuplot/term/iris4d.trm'`"
  128. test 5305 -eq "$Wc_c" ||
  129.     echo 'gnuplot/term/iris4d.trm: original size 5305, current size' "$Wc_c"
  130. rm -f _shar_wnt_.tmp
  131. fi
  132. # ============= gnuplot/term/kyo.trm ==============
  133. if test -f 'gnuplot/term/kyo.trm' -a X"$1" != X"-c"; then
  134.     echo 'x - skipping gnuplot/term/kyo.trm (File already exists)'
  135.     rm -f _shar_wnt_.tmp
  136. else
  137. > _shar_wnt_.tmp
  138. echo 'x - extracting gnuplot/term/kyo.trm (Text)'
  139. sed 's/^X//' << 'SHAR_EOF' > 'gnuplot/term/kyo.trm' &&
  140. /* Prescribe (KYOCERA) driver - Michael Waldor */
  141. /* Modified for gnuplot 2.0 sk@sun4 24-Apr-1990 13:23 */
  142. #ifdef PRESCRIBE
  143. X
  144. #define PRE_XMAX 2567
  145. #define PRE_YMAX 1815    /* X:Y = sqrt(2) */
  146. X
  147. #define PRE_XLAST (PRE_XMAX - 1)
  148. #define PRE_YLAST (PRE_YMAX - 1)
  149. X
  150. #define PRE_VCHAR (PRE_YMAX/30)
  151. #define PRE_HCHAR 33    /* about 9 chars per inch */
  152. #define PRE_HTIC (PRE_XMAX/80)
  153. #define PRE_VTIC PRE_HTIC
  154. X
  155. /* for Courier font: */
  156. #define KYO_VCHAR (14*(300/72))    /* 12 pt + 2 pt baselineskip */
  157. #define KYO_HCHAR (300/10)    /*  10 chars per inch */
  158. X
  159. enum JUSTIFY pre_justify=LEFT;    /* text is flush left */
  160. X
  161. PRE_init()
  162. {
  163. X  (void) fprintf(outfile,"!R! RES;\n") ;
  164. X  /* UNIT: units are dots, 300 dots = 1 in = 72 pt */
  165. X  /* SPO: landscape format */
  166. X  /* STM, SLM set top, left margin*/
  167. X  /* Font: bold Helvetica (proportional font) */
  168. X  (void) fprintf(outfile,"PAGE; UNIT D; SPO L; STM 280; SLM 440;\n") ;
  169. X  (void) fprintf(outfile,"FTMD 15; FONT 29; SCPI 9;\n") ;
  170. }
  171. X
  172. KYO_init()
  173. {
  174. X  (void) fprintf(outfile,"!R! RES;\n") ;
  175. X  /* UNIT: units are dots, 300 dots = 1 in = 72 pt */
  176. X  /* SPO: landscape format */
  177. X  /* STM, SLM set top, left margin */
  178. X  /* Font: Courier (fixed width font) */
  179. X  (void) fprintf(outfile,"PAGE; UNIT D; SPO L; STM 280; SLM 440;\n") ;
  180. X  (void) fprintf(outfile,"FTMD 15; FONT 17; SCPI 10;\n") ;
  181. }
  182. X
  183. PRE_graphics()
  184. {
  185. }
  186. X
  187. PRE_text()            /* eject page after each plot */
  188. {
  189. X  (void) fprintf(outfile,"PAGE;\n") ; 
  190. }
  191. X
  192. PRE_linetype(linetype)
  193. int linetype ;
  194. {
  195. X  /* actually choose pendiameter */
  196. X  if (linetype < 0) linetype = -linetype;
  197. X  else linetype = 3;
  198. X  (void) fprintf(outfile,"SPD %d;\n", linetype) ;
  199. }
  200. X 
  201. PRE_move(x,y)
  202. unsigned int x,y ;
  203. {
  204. X  (void) fprintf(outfile,"MAP %1d,%1d;\n",x,PRE_YMAX-y) ;
  205. }
  206. X 
  207. PRE_vector(x,y)
  208. unsigned int x,y ;
  209. {
  210. X  (void) fprintf(outfile,"DAP %1d, %1d;\n",x,PRE_YMAX-y) ;
  211. }
  212. X 
  213. PRE_put_text(x, y, str)
  214. unsigned int x,y ;
  215. char *str;
  216. {
  217. X  PRE_move(x,y);
  218. X  switch(pre_justify){
  219. X  case RIGHT:
  220. X    (void) fprintf(outfile,"RTXT \"%s\", B;\n",str) ;
  221. X    break;
  222. X  default:
  223. X    (void) fprintf(outfile,"TEXT \"%s\", B;\n",str) ;
  224. X  }
  225. }
  226. X 
  227. int PRE_justify_text(mode)
  228. enum JUSTIFY mode;
  229. {
  230. X  pre_justify=mode;
  231. X  switch(pre_justify){
  232. X  case LEFT:
  233. X  case RIGHT:
  234. X    return(TRUE);
  235. X  default:
  236. X    return(FALSE);
  237. X  }
  238. X  
  239. }
  240. X
  241. PRE_reset()
  242. {
  243. X  (void) fprintf(outfile,"PAGE; RES; EXIT;\n");
  244. }
  245. X
  246. #endif /* PRESCRIBE */
  247. SHAR_EOF
  248. chmod 0666 gnuplot/term/kyo.trm ||
  249. echo 'restore of gnuplot/term/kyo.trm failed'
  250. Wc_c="`wc -c < 'gnuplot/term/kyo.trm'`"
  251. test 2313 -eq "$Wc_c" ||
  252.     echo 'gnuplot/term/kyo.trm: original size 2313, current size' "$Wc_c"
  253. rm -f _shar_wnt_.tmp
  254. fi
  255. # ============= gnuplot/term/latex.trm ==============
  256. if test -f 'gnuplot/term/latex.trm' -a X"$1" != X"-c"; then
  257.     echo 'x - skipping gnuplot/term/latex.trm (File already exists)'
  258.     rm -f _shar_wnt_.tmp
  259. else
  260. > _shar_wnt_.tmp
  261. echo 'x - extracting gnuplot/term/latex.trm (Text)'
  262. sed 's/^X//' << 'SHAR_EOF' > 'gnuplot/term/latex.trm' &&
  263. /* GNUPLOT - latex.trm */
  264. /*
  265. X * Copyright (C) 1990   
  266. X *
  267. X * Permission to use, copy, and distribute this software and its
  268. X * documentation for any purpose with or without fee is hereby granted, 
  269. X * provided that the above copyright notice appear in all copies and 
  270. X * that both that copyright notice and this permission notice appear 
  271. X * in supporting documentation.
  272. X *
  273. X * Permission to modify the software is granted, but not the right to
  274. X * distribute the modified code.  Modifications are to be distributed 
  275. X * as patches to released version.
  276. X *  
  277. X * This software  is provided "as is" without express or implied warranty.
  278. X * 
  279. X * This file is included by ../term.c.
  280. X *
  281. X * This terminal driver supports:
  282. X *   LaTeX pictures (latex).
  283. X *   LaTeX pictures with emTeX specials (emtex). 
  284. X *
  285. X * AUTHORS
  286. X *   David Kotz, Russell Lang
  287. X *
  288. X * send your comments or suggestions to (pixar!info-gnuplot@sun.com).
  289. X * 
  290. X */
  291. X
  292. /* modified to optimize use of \rule for long lines */
  293. X
  294. /* the following LATEX driver has been modified by 
  295. X   Russell Lang, eln272v@monu1.cc.monash.oz from the
  296. X   GnuTeX 1.3 driver by David Kotz, David.Kotz@Dartmouth.edu.
  297. X   Since then it has been further extended by David Kotz.
  298. X   EmTeX driver by Russell Lang. */
  299. X
  300. X
  301. #define LATEX_PTS_PER_INCH (72.27)
  302. #define DOTS_PER_INCH (300)    /* resolution of printer we expect to use */
  303. #define LATEX_UNIT (LATEX_PTS_PER_INCH/DOTS_PER_INCH) /* dot size in pt */
  304. X
  305. /* 5 inches wide by 3 inches high (default) */
  306. #define LATEX_XMAX (5*DOTS_PER_INCH)  /* (LATEX_PTS_PER_INCH/LATEX_UNIT*5.0) */
  307. #define LATEX_YMAX (3*DOTS_PER_INCH)  /* (LATEX_PTS_PER_INCH/LATEX_UNIT*3.0) */
  308. X
  309. #define LATEX_HTIC (5*DOTS_PER_INCH/72)        /* (5./LATEX_UNIT) */
  310. #define LATEX_VTIC (5*DOTS_PER_INCH/72)        /* (5./LATEX_UNIT) */
  311. #define LATEX_HCHAR (DOTS_PER_INCH*53/10/72)    /* (5.3/LATEX_UNIT) */
  312. #define LATEX_VCHAR (DOTS_PER_INCH*11/72)    /* (11./LATEX_UNIT) */
  313. X
  314. static int LATEX_posx;
  315. static int LATEX_posy;
  316. static enum JUSTIFY latex_justify=LEFT;
  317. static int latex_angle=0;
  318. X
  319. /* Default line-drawing character */
  320. /* the definition of plotpoint varies with linetype */
  321. #define LATEX_DOT "\\usebox{\\plotpoint}"
  322. #define LATEX_TINY_DOT "\\rule{.1pt}{.1pt}" /* for dots plot style */
  323. X
  324. /* POINTS */
  325. #define LATEX_POINT_TYPES 12    /* we supply more point types */
  326. static char *LATEX_points[] = {
  327. X    "\\raisebox{-1.2pt}{\\makebox(0,0){$\\Diamond$}}",
  328. X    "\\makebox(0,0){$+$}",
  329. X    "\\raisebox{-1.2pt}{\\makebox(0,0){$\\Box$}}",
  330. X    "\\makebox(0,0){$\\times$}",
  331. X    "\\makebox(0,0){$\\triangle$}",
  332. X    "\\makebox(0,0){$\\star$}",
  333. X    "\\circle{12}", "\\circle{18}", "\\circle{24}",
  334. X    "\\circle*{12}", "\\circle*{18}", "\\circle*{24}"
  335. };
  336. X
  337. /* LINES */
  338. static float LATEX_size = 0;    /* current thick of line in points */
  339. static float LATEX_dotspace = 0; /* current dotspace of line in points */
  340. #define LATEX_LINE_TYPES 6    /* number of line types below */
  341. #define LATEX_THIN_LINE 0    /* the thinnest solid line type */
  342. static struct {
  343. X    float size;            /* size of dot, or thick of line in points */
  344. X    float dotspace;            /* inter-dot space in points; 0 for lines */
  345. } LATEX_lines[] = {
  346. X    {.35, 0.0},                /* thin solid line */
  347. X    {.7, 0.0},                /* thick solid line */
  348. X    {1.0, 0.0},                /* Thick solid line */
  349. X    {.5, 5.0},                /* dotted line */
  350. X    {.5, 9.0},                /* widely dotted line */
  351. X    {.5, 13.0}                /* really widely dotted line */
  352. };
  353. /* for drawing dotted and solid lines */
  354. static void LATEX_dot_line();
  355. static void LATEX_solid_line();
  356. static void LATEX_rule();
  357. static void LATEX_flushdot();
  358. #define LATEX_flushrule() LATEX_rule(2, 0.,0.,0.,0.) /* flush old rule */
  359. static BOOLEAN LATEX_moved = TRUE;    /* pen is up after move */
  360. static float LATEX_dotsize;    /* size of LATEX_DOT in units */
  361. static BOOLEAN LATEX_needsdot = FALSE;/* does dotted line need termination? */
  362. X
  363. #ifdef EMTEX
  364. BOOLEAN emtex=FALSE; /* not currently using emtex */
  365. static void EMTEX_solid_line();
  366. #endif
  367. X
  368. /* ARROWS */
  369. /* the set of non-vertical/non-horizontal LaTeX vector slopes */
  370. /* except negatives - they are handled specially */
  371. static struct vslope {
  372. X    int dx, dy;
  373. } LATEX_slopes[] = {
  374. X    {1,1}, {1,2}, {1,3}, {1,4},
  375. X    {2,1}, {2,3},
  376. X    {3,1}, {3,2}, {3,4},
  377. X    {4,1}, {4,3},
  378. X    {0,0}                    /* terminator */
  379. };
  380. static void best_latex_arrow(); /* figure out the best arrow */
  381. X
  382. LATEX_init()
  383. {
  384. #ifdef EMTEX
  385. X    emtex = FALSE;
  386. #endif
  387. X    LATEX_posx = LATEX_posy = 0;
  388. X    fprintf(outfile, "%% GNUPLOT: LaTeX picture\n");
  389. X    fprintf(outfile, "\\setlength{\\unitlength}{%fpt}\n", LATEX_UNIT);
  390. X    fprintf(outfile, 
  391. X          "\\ifx\\plotpoint\\undefined\\newsavebox{\\plotpoint}\\fi\n");
  392. X    LATEX_linetype(-1);
  393. }
  394. X
  395. X
  396. LATEX_scale(xs, ys)
  397. X    double xs, ys;            /* scaling factors */
  398. {
  399. X    register struct termentry *t = &term_tbl[term];
  400. X
  401. X    /* we change the table for use in graphics.c and LATEX_graphics */
  402. X    t->xmax = (unsigned int)(LATEX_XMAX * xs);
  403. X    t->ymax = (unsigned int)(LATEX_YMAX * ys);
  404. X
  405. X    return(TRUE);
  406. }
  407. X
  408. LATEX_graphics()
  409. {
  410. X    register struct termentry *t = &term_tbl[term];
  411. X
  412. X    fprintf(outfile, "\\begin{picture}(%d,%d)(0,0)\n", t->xmax, t->ymax);
  413. X    fprintf(outfile, "\\tenrm\n");
  414. }
  415. X
  416. X
  417. LATEX_text()
  418. {
  419. X    LATEX_flushrule();
  420. X    LATEX_flushdot();
  421. X    fprintf(outfile, "\\end{picture}\n");
  422. X    LATEX_posx = LATEX_posy = 0; /* current position */
  423. X    LATEX_moved = TRUE;    /* pen is up after move */
  424. }
  425. X
  426. LATEX_linetype(linetype)
  427. X    int linetype;
  428. {
  429. X    float size;
  430. X
  431. X    if (linetype >= LATEX_LINE_TYPES)
  432. X     linetype %= LATEX_LINE_TYPES;
  433. X
  434. #ifdef EMTEX
  435. X    if (!emtex)
  436. #endif
  437. X    LATEX_flushrule();
  438. X    LATEX_flushdot();
  439. X
  440. X    /* Find the new desired line thickness. */
  441. X    /* negative linetypes (for axes) use a thin line */
  442. X    /* only relevant for drawing axes/border in 3d */
  443. X    size = (linetype >= 0 ? LATEX_lines[linetype].size 
  444. X          : LATEX_lines[LATEX_THIN_LINE].size);
  445. X
  446. X    /* If different from current size, redefine \plotpoint */
  447. X    if (size != LATEX_size) {
  448. X       fprintf(outfile, 
  449. X             "\\sbox{\\plotpoint}{\\rule[%.3fpt]{%.3fpt}{%.3fpt}}%%\n",
  450. X             -size/2, size, size);
  451. #ifdef EMTEX
  452. X        if (emtex)         /* change line width */
  453. X        fprintf(outfile, "\\special{em:linewidth %.1fpt}%%\n", size);
  454. #endif
  455. X    }
  456. X    
  457. X    LATEX_size = size;
  458. X    LATEX_dotsize = size / LATEX_UNIT;
  459. X    LATEX_dotspace = (linetype >= 0) ? LATEX_lines[linetype].dotspace : 0;
  460. X    LATEX_moved = TRUE;            /* reset */
  461. }
  462. X
  463. LATEX_move(x,y)
  464. X    unsigned int x,y;
  465. {
  466. X    LATEX_flushdot();
  467. X
  468. X    LATEX_posx = x;
  469. X    LATEX_posy = y;
  470. X    LATEX_moved = TRUE;            /* reset */
  471. }
  472. X
  473. X
  474. LATEX_point(x,y, number)        /* version of line_and_point */
  475. X    unsigned int x,y;
  476. X    int number;                /* type of point */
  477. {
  478. X    LATEX_move(x,y);
  479. X    
  480. X    /* Print the character defined by 'number'; number < 0 means 
  481. X      to use a dot, otherwise one of the defined points. */
  482. X    fprintf(outfile, "\\put(%d,%d){%s}\n", x, y, 
  483. X          (number < 0 ? LATEX_TINY_DOT
  484. X           : LATEX_points[number % LATEX_POINT_TYPES]));
  485. }
  486. X
  487. X
  488. LATEX_vector(ux,uy)
  489. X    unsigned int ux,uy;
  490. {
  491. X    if (LATEX_dotspace == 0.0) {
  492. X       /* solid line */
  493. #ifdef EMTEX
  494. X       if (emtex)
  495. X        EMTEX_solid_line(LATEX_posx, (int)ux, LATEX_posy, (int)uy);
  496. X       else
  497. #endif
  498. X        LATEX_solid_line(LATEX_posx, (int)ux, LATEX_posy, (int)uy);
  499. X    } else
  500. X     /* dotted line */
  501. X     LATEX_dot_line(LATEX_posx, (int)ux, LATEX_posy, (int)uy);
  502. X
  503. X    LATEX_posx = ux;
  504. X    LATEX_posy = uy;
  505. }
  506. X
  507. static void
  508. LATEX_solid_line(x1,x2, y1,y2)
  509. X    int x1,x2, y1,y2;
  510. {
  511. X    float slope;
  512. X    int inc;
  513. X    float next;
  514. X    float x,y;
  515. X    int code;                /* possibly combine with previous rule */
  516. X
  517. X    /* we draw a solid line using the current line thickness (size) */
  518. X    /* we do it with lots of \\rules */
  519. X
  520. X    if (x1 == x2 && y1 == y2) { /* zero-length line - just a dot */
  521. X       if (LATEX_moved) {
  522. X          LATEX_flushrule();
  523. X          /* plot a dot */
  524. X          fprintf(outfile, "\\put(%u,%u){%s}\n", x1, y1, LATEX_DOT);
  525. X       }
  526. X    } else {
  527. X       code = (LATEX_moved ? 0 : 1); /* no combine after move */
  528. X       if (x1 == x2)        /* vertical line - special case */
  529. X        LATEX_rule(code, (double)x1, (double)y1,
  530. X               LATEX_dotsize, (double)y2-y1);
  531. X       else if (y1 == y2)    /* horizontal line - special case */
  532. X        LATEX_rule(code, (double)x1, (double)y1, (double)x2-x1,
  533. X               LATEX_dotsize);
  534. X       else {
  535. X          slope = ((float)y2-y1)/((float)x2-x1);
  536. X          if (abs(slope) <= 1.0) {
  537. X             /* longer than high */
  538. X             inc = sign(y2-y1);
  539. X             for (x = x1, y = y1; (y2-y)*inc >= 0; y += inc) {
  540. X                next = inc/slope + x;
  541. X                if ((x2>x1 && next > x2) || (x2<x1 && next < x2)) {
  542. X                    LATEX_rule(code, x,y, x2-x, LATEX_dotsize);
  543. X                    break;
  544. X                } else {
  545. X                    LATEX_rule(code, x,y, next-x, LATEX_dotsize);
  546. X                    x = next;
  547. X                }
  548. X                code = 0;
  549. X             }
  550. X          } else {
  551. X             /* higher than long */
  552. X             inc = sign(x2-x1);
  553. X             for (x = x1, y = y1; (x2-x)*inc >= 0; x += inc) {
  554. X                next = inc*slope + y;
  555. X                if ((y2>y1 && next > y2) || (y2<y1 && next < y2)) {
  556. X                    LATEX_rule(code, x,y, LATEX_dotsize, y2-y);
  557. X                    break;
  558. X                } else {
  559. X                    LATEX_rule(code, x,y, LATEX_dotsize, next-y);
  560. X                    y = next;
  561. X                }
  562. X                code = 0;
  563. X             }
  564. X          }
  565. X       }
  566. X    }
  567. X    LATEX_moved = FALSE;
  568. }
  569. X
  570. /* Draw a \rule. Width or height may be negative; we can correct.
  571. X * The rule is never output immediately. The previous rule is output
  572. X * as-is if code is 0, and the previous rule is
  573. X * combined with the current rule (if possible) if code is 1.
  574. X * The previous rule is output, and the new one ignored, if code is 2.
  575. X */
  576. static void
  577. LATEX_rule(code, x,y, width, height)
  578. X    int code;                /* how do we treat this rule? */
  579. X    double x, y;
  580. X    double width;
  581. X    double height;
  582. {  
  583. X    static float lastx, lasty;
  584. X    static float lastw, lasth;
  585. X    static BOOLEAN valid = FALSE; /* is 'last' data valid? */
  586. X    BOOLEAN combine = (code == 1);
  587. X    BOOLEAN flush = (code == 2);
  588. X
  589. X    if (!flush)
  590. X     if (width == 0 || height == 0)
  591. X       return;            /* ignore this rule */
  592. X
  593. X    if (valid && combine) {
  594. X       /* try to combine new rule with old rule */
  595. X       if ((int)lastx == (int)x && lastw == width) { /* vertical rule */
  596. X          if (lasth * height >= 0) { /* same sign */
  597. X             lasth += height;
  598. X             return;
  599. X          }
  600. X       } else if ((int)lasty == (int)y && lasth == height){ /* horiz rule */
  601. X          if (lastw * width >= 0) { /* same sign */
  602. X             lastw += width;
  603. X             return;
  604. X          }
  605. X       }
  606. X       /* oh well, output last and remember the new one */
  607. X    }
  608. X
  609. X    if (valid) {
  610. X       /* output the rule */
  611. X       if (lastw < 0) {
  612. X          lastx += lastw;
  613. X          lastw = -lastw;
  614. X       }
  615. X       if (lasth < 0) {
  616. X          lasty += lasth;
  617. X          lasth = -lasth;
  618. X       }
  619. X
  620. X       /* if very small use canned dot */
  621. X       if (lastw < LATEX_dotsize || lasth < LATEX_dotsize)
  622. X        fprintf(outfile, "\\put(%d,%d){%s}\n",       
  623. X               (int)lastx, (int)lasty, LATEX_DOT);
  624. X       else
  625. X        fprintf(outfile, "\\put(%d,%d){\\rule[%.3fpt]{%.3fpt}{%.3fpt}}\n",
  626. X               (int)lastx, (int)lasty, -LATEX_dotsize*LATEX_UNIT/2,
  627. X               lastw*LATEX_UNIT, lasth*LATEX_UNIT);
  628. X    }
  629. X    
  630. X    if (flush) {
  631. X       valid = FALSE;
  632. X    } else {
  633. X       lastx = x; lasty = y;
  634. X       lastw = width; lasth = height;
  635. X       valid = TRUE;
  636. X    }
  637. }
  638. X
  639. static void
  640. LATEX_dot_line(x1,x2, y1,y2)
  641. X    int x1,x2, y1,y2;
  642. {
  643. X    static float LATEX_left;    /* fraction of space left after last dot */
  644. #ifndef AMIGA_AC_5
  645. X    extern double sqrt();
  646. #endif
  647. X    /* we draw a dotted line using the current dot spacing */
  648. X
  649. X    if (LATEX_moved)
  650. X     LATEX_left = 1.0;        /* reset after a move */
  651. X
  652. X    /* zero-length line? */
  653. X    if (x1 == x2 && y1 == y2) {
  654. X       if (LATEX_moved)
  655. X        /* plot a dot */
  656. X        fprintf(outfile, "\\put(%u,%u){%s}\n", x1, y1, LATEX_DOT);
  657. X    } else {
  658. X       float dotspace = LATEX_dotspace / LATEX_UNIT;
  659. X       float x,y;            /* current position */
  660. X       float xinc, yinc;    /* increments */
  661. X       float slope;        /* slope of line */
  662. X       float lastx = -1;    /* last x point plotted */
  663. X       float lasty = -1;    /* last y point plotted */
  664. X
  665. X       /* first, figure out increments for x and y */
  666. X       if (x2 == x1) {
  667. X          xinc = 0.0;
  668. X          yinc = dotspace;
  669. X       } else {
  670. X          slope = ((float)y2-y1)/((float)x2-x1);
  671. X          xinc = dotspace / sqrt(1 + slope*slope) * sign(x2-x1);
  672. X          yinc = slope * xinc;
  673. X       }
  674. X       
  675. X       /* now draw the dotted line */
  676. X       /* we take into account where we last placed a dot */
  677. X       for (x=x1 + xinc*(1-LATEX_left), y=y1 + yinc*(1-LATEX_left);
  678. X           (x2-x)*xinc >= 0 && (y2-y)*yinc >= 0; /* same sign or zero */
  679. X           lastx = x, x += xinc, 
  680. X           lasty = y, y += yinc)
  681. X        fprintf(outfile, "\\put(%d,%d){%s}\n", (int)x, (int)y, LATEX_DOT);
  682. X
  683. X       /* how much is left over, as a fraction of dotspace? */
  684. X       if (xinc != 0.0)            /* xinc must be nonzero */
  685. X        if (lastx >= 0)
  686. X          LATEX_left = abs(x2 - lastx) / abs(xinc);
  687. X        else
  688. X          LATEX_left += abs(x2-x1) / abs(xinc);
  689. X       else
  690. X        if (lasty >= 0)
  691. X          LATEX_left = abs(y2 - lasty) / abs(yinc);
  692. X        else
  693. X          LATEX_left += abs(y2-y1) / abs(yinc);
  694. X    }
  695. X
  696. X    LATEX_needsdot = (LATEX_left > 0);
  697. X
  698. X    LATEX_moved = FALSE;
  699. }
  700. X
  701. static void
  702. LATEX_flushdot()
  703. {
  704. X    if (LATEX_needsdot) 
  705. X     fprintf(outfile, "\\put(%d,%d){%s}\n", 
  706. X            LATEX_posx, LATEX_posy, LATEX_DOT);
  707. X    LATEX_needsdot = FALSE;
  708. }
  709. X
  710. LATEX_arrow(sx,sy, ex,ey, head)
  711. X    int sx,sy, ex,ey;
  712. X    BOOLEAN head;
  713. {
  714. X    best_latex_arrow(sx,sy, ex,ey, 1, head);
  715. X
  716. X    LATEX_posx = ex;
  717. X    LATEX_posy = ey;
  718. }
  719. X
  720. static void best_latex_arrow(sx,sy, ex,ey, who, head)
  721. X    int sx,sy, ex,ey;        /* start and end points */
  722. X    int who;                /* 1=LATEX, 2=EEPIC */
  723. X    BOOLEAN head;
  724. {
  725. X    int dx = ex - sx;
  726. X    int dy = ey - sy;
  727. X    int x, y;                /* points near sx,sy */
  728. X    float m;                /* slope of line */
  729. X    float arrowslope;        /* slope of arrow */
  730. X    float minerror = 0;        /* best-case error */
  731. X    struct vslope *slope;    /* one of the slopes */
  732. X    struct vslope *bestslope;    /* the slope with min error */
  733. X    BOOLEAN horiz;            /* was it the horiz line that was best? */
  734. X
  735. X    /* We try to draw a real arrow (ie, \vector). If we can't get
  736. X    * a slope that is close, we draw a bent arrow.
  737. X    */
  738. X
  739. X    if (dx == 0) {
  740. X       /* vertical arrow */
  741. X       fprintf(outfile, "\\put(%d,%d){\\%s(0,%d){%d}}\n",
  742. X             sx, sy, head ? "vector":"line", 
  743. X             sign(ey-sy), abs(ey-sy));
  744. X    } else if (dy == 0) {
  745. X       /* horizontal arrow */
  746. X       fprintf(outfile, "\\put(%d,%d){\\%s(%d,0){%d}}\n",
  747. X             sx, sy, head ? "vector":"line",
  748. X             sign(ex-sx), abs(ex-sx));
  749. X    } else {
  750. X       /* Slanted arrow. We'll give it a try.
  751. X        * we try to find the closest-slope arrowhead.
  752. X        */
  753. X       bestslope = NULL;
  754. X       minerror = 0; /* to shut up turbo C */
  755. X       m = abs((float)dy/dx); /* the slope we want */
  756. X       for (slope = LATEX_slopes; slope->dx != 0.0; slope++) {
  757. X          /* find the slope of the arrow */
  758. X          arrowslope = (float) slope->dy / slope->dx;
  759. X          if (bestslope == NULL || abs(m-arrowslope) < minerror) {
  760. X             minerror = abs(m-arrowslope);
  761. X             bestslope = slope;
  762. X          }
  763. X       }
  764. X
  765. X       /* now we have the best slope arrow */
  766. X       /* maybe it's exactly the right slope! */
  767. X       if (minerror == 0.0)    /* unlikely but possible */
  768. X        fprintf(outfile, "\\put(%d,%d){\\%s(%d,%d){%d}}\n",
  769. X               sx, sy, head ? "vector" : "line",
  770. X               bestslope->dx*sign(ex-sx), bestslope->dy*sign(ey-sy),
  771. X               abs(ex-sx));
  772. X       else {
  773. X          /* we draw the line the usual way, with thin lines */
  774. #ifdef EMTEX
  775. X          if (emtex) {
  776. X             LATEX_linetype(LATEX_THIN_LINE);
  777. X             EMTEX_solid_line(sx,ex,sy,ey);
  778. X          } else 
  779. #endif
  780. X            if (who == 1) {
  781. X               LATEX_linetype(LATEX_THIN_LINE);
  782. X               LATEX_solid_line(sx,ex,sy,ey);
  783. X            }
  784. #ifdef EEPIC
  785. X            else {
  786. X               EEPIC_move(sx,sy);
  787. X               EEPIC_vector(ex,ey);
  788. X            }
  789. #endif /* EEPIC */
  790. X          /* and then draw an arrowhead (a short vector) there */
  791. X            if (head)
  792. X                  fprintf(outfile, "\\put(%d,%d){\\vector(%d,%d){0}}\n",
  793. X                ex, ey, 
  794. X                bestslope->dx*sign(ex-sx), bestslope->dy*sign(ey-sy));
  795. X       }
  796. X    }
  797. }
  798. X
  799. X
  800. LATEX_put_text(x, y, str)
  801. X    int x,y;                /* reference point of string */
  802. X    char str[];            /* the text */
  803. {
  804. X    /* ignore empty strings */
  805. X    if (str[0] == '\0')
  806. X     return;
  807. X
  808. X    fprintf(outfile, "\\put(%d,%d)",x,y);
  809. X    switch(latex_angle) {  
  810. X        case 0: {
  811. X          switch(latex_justify) {
  812. X             case LEFT: {
  813. X                fprintf(outfile,
  814. X                       "{\\makebox(0,0)[l]{%s}}\n", str);
  815. X                break;
  816. X             }
  817. X             case CENTRE: {
  818. X                fprintf(outfile,
  819. X                       "{\\makebox(0,0){%s}}\n", str);
  820. X                break;
  821. X             }
  822. X             case RIGHT: {
  823. X                fprintf(outfile,
  824. X                       "{\\makebox(0,0)[r]{%s}}\n", str);
  825. X                break;
  826. X             }
  827. X          }
  828. X          break;
  829. X       }
  830. X       case 1: {            /* put text in a short stack */
  831. X          switch(latex_justify) {
  832. X             case LEFT: {
  833. X                fprintf(outfile,
  834. X                       "{\\makebox(0,0)[lb]{\\shortstack{%s}}}\n", str);
  835. X                break;
  836. X             }
  837. X             case CENTRE: {
  838. X                fprintf(outfile,
  839. X                       "{\\makebox(0,0)[l]{\\shortstack{%s}}}\n", str);
  840. X                break;
  841. X             }
  842. X             case RIGHT: {
  843. X                fprintf(outfile,
  844. X                       "{\\makebox(0,0)[lt]{\\shortstack{%s}}}\n", str);
  845. X                break;
  846. X             }
  847. X          }
  848. X          break;
  849. X       }    
  850. X    }
  851. }
  852. X
  853. X
  854. X
  855. int LATEX_justify_text(mode)
  856. X    enum JUSTIFY mode;
  857. {
  858. X    latex_justify = mode;
  859. X    return (TRUE);
  860. }
  861. X
  862. int LATEX_text_angle(angle)
  863. X    int angle;
  864. {
  865. X    /* we can't really write text vertically, but this will 
  866. X      put the ylabel centred at the left of the plot, and
  867. X      then we'll make a \shortstack */
  868. X    latex_angle = angle;
  869. X    return (TRUE);
  870. }
  871. X
  872. LATEX_reset()
  873. {
  874. X    LATEX_posx = LATEX_posy = 0; /* current position */
  875. X    LATEX_moved = TRUE;    /* pen is up after move */
  876. }
  877. X
  878. X
  879. #ifdef EMTEX
  880. X
  881. EMTEX_init()
  882. {
  883. X    emtex=TRUE;
  884. X    LATEX_posx = LATEX_posy = 0;
  885. X    fprintf(outfile, "%% GNUPLOT: LaTeX picture with emtex specials\n");
  886. X    fprintf(outfile, "\\setlength{\\unitlength}{%fpt}\n", LATEX_UNIT);
  887. X    fprintf(outfile, 
  888. X          "\\ifx\\plotpoint\\undefined\\newsavebox{\\plotpoint}\\fi\n");
  889. X    LATEX_linetype(-1);
  890. }
  891. X
  892. X
  893. EMTEX_reset()
  894. {
  895. X    emtex=FALSE;
  896. X    LATEX_posx = LATEX_posy = 0;
  897. }
  898. X
  899. X
  900. EMTEX_text()
  901. {
  902. X    fprintf(outfile, "\\end{picture}\n");
  903. }
  904. X
  905. X
  906. static void
  907. EMTEX_solid_line(x1,x2, y1,y2)
  908. X    int x1,x2, y1,y2;
  909. {
  910. X    /* emtex special solid line */
  911. X    if (LATEX_moved)
  912. X        fprintf(outfile, "\\put(%d,%d){\\special{em:moveto}}\n", x1, y1);
  913. X    if ( (x1!=x2) || (y1!=y2) )
  914. X        fprintf(outfile, "\\put(%d,%d){\\special{em:lineto}}\n", x2, y2);
  915. X    LATEX_posx = x2;
  916. X    LATEX_posy = y2;
  917. X    LATEX_moved = FALSE;
  918. }
  919. X
  920. X
  921. #endif /* EMTEX */
  922. SHAR_EOF
  923. chmod 0644 gnuplot/term/latex.trm ||
  924. echo 'restore of gnuplot/term/latex.trm failed'
  925. Wc_c="`wc -c < 'gnuplot/term/latex.trm'`"
  926. test 17764 -eq "$Wc_c" ||
  927.     echo 'gnuplot/term/latex.trm: original size 17764, current size' "$Wc_c"
  928. rm -f _shar_wnt_.tmp
  929. fi
  930. # ============= gnuplot/term/object.h ==============
  931. if test -f 'gnuplot/term/object.h' -a X"$1" != X"-c"; then
  932.     echo 'x - skipping gnuplot/term/object.h (File already exists)'
  933.     rm -f _shar_wnt_.tmp
  934. else
  935. > _shar_wnt_.tmp
  936. echo 'x - extracting gnuplot/term/object.h (Text)'
  937. sed 's/^X//' << 'SHAR_EOF' > 'gnuplot/term/object.h' &&
  938. /* 
  939. X *    FIG : Facility for Interactive Generation of figures
  940. X *
  941. X *    (c) copy right 1985 by Supoj Sutanthavibul (supoj@sally.utexas.edu)
  942. X *      January 1985.
  943. X *    1st revision : Aug 1985.
  944. X *    2nd revision : Feb 1988.
  945. X *
  946. X *    %W%    %G%
  947. */
  948. #define                    DEFAULT            -1
  949. X
  950. typedef        struct f_pattern {
  951. X            int            w, h;
  952. X            int            *p;
  953. X            }
  954. X        F_pattern;
  955. X
  956. typedef        struct f_pen {
  957. X            int            x, y;
  958. X            int            *p;
  959. X            }
  960. X        F_pen;
  961. X
  962. typedef        struct f_point {
  963. X            int            x, y;
  964. X            struct f_point        *next;
  965. X            }
  966. X        F_point;
  967. X
  968. typedef        struct f_pos {
  969. X            int            x, y;
  970. X            }
  971. X        F_pos;
  972. X
  973. typedef        struct f_arrow {
  974. X            int            type;
  975. X            int            style;
  976. X            float            thickness;
  977. X            float            wid;
  978. X            float            ht;
  979. X            }
  980. X        F_arrow;
  981. X
  982. typedef        struct f_ellipse {
  983. X            int            type;
  984. #define                    T_ELLIPSE_BY_RAD    1
  985. #define                    T_ELLIPSE_BY_DIA    2
  986. #define                    T_CIRCLE_BY_RAD        3
  987. #define                    T_CIRCLE_BY_DIA        4
  988. X            int            style;
  989. X            int            thickness;
  990. X            int            color;
  991. #define                    BLACK            0
  992. X            int            depth;
  993. X            int            direction;
  994. X            float            style_val;
  995. X            float            angle;
  996. X            struct f_pen        *pen;
  997. X            struct f_pattern    *area_fill;
  998. #define                           UNFILLED    (F_pattern *)0
  999. #define                           BLACK_FILL    (F_pattern *)1
  1000. #define                           DARK_GRAY_FILL    (F_pattern *)2
  1001. #define                           MED_GRAY_FILL    (F_pattern *)3
  1002. #define                           LIGHT_GRAY_FILL    (F_pattern *)4
  1003. #define                           WHITE_FILL    (F_pattern *)4
  1004. X            struct f_pos        center;
  1005. X            struct f_pos        radiuses;
  1006. X            struct f_pos        start;
  1007. X            struct f_pos        end;
  1008. X            struct f_ellipse    *next;
  1009. X            }
  1010. X        F_ellipse;
  1011. X
  1012. typedef        struct f_arc {
  1013. X            int            type;
  1014. #define                    T_3_POINTS_ARC        1
  1015. X            int            style;
  1016. X            int            thickness;
  1017. X            int            color;
  1018. X            int            depth;
  1019. X            struct f_pen        *pen;
  1020. X            struct f_pattern    *area_fill;
  1021. X            float            style_val;
  1022. X            int            direction;
  1023. X            struct f_arrow        *for_arrow;
  1024. X            struct f_arrow        *back_arrow;
  1025. X            struct {float x, y;}    center;
  1026. X            struct f_pos        point[3];
  1027. X            struct f_arc        *next;
  1028. X            }
  1029. X        F_arc;
  1030. X
  1031. typedef        struct f_line {
  1032. X            int            type;
  1033. #define                    T_POLYLINE    1
  1034. #define                    T_BOX        2
  1035. #define                    T_POLYGON    3
  1036. X            int            style;
  1037. X            int            thickness;
  1038. X            int            color;
  1039. X            int            depth;
  1040. X            float            style_val;
  1041. X            struct f_pen        *pen;
  1042. X            struct f_pattern    *area_fill;
  1043. X            struct f_arrow        *for_arrow;
  1044. X            struct f_arrow        *back_arrow;
  1045. X            struct f_point        *points;
  1046. X            struct f_line        *next;
  1047. X            }
  1048. X        F_line;
  1049. X
  1050. typedef        struct f_text {
  1051. X            int            type;
  1052. #define                    T_LEFT_JUSTIFIED    0
  1053. #define                    T_CENTER_JUSTIFIED    1
  1054. #define                    T_RIGHT_JUSTIFIED    2
  1055. X            int            font;
  1056. #define                    DEFAULT_FONT        0
  1057. #define                    ROMAN_FONT        1
  1058. #define                    BOLD_FONT        2
  1059. #define                    ITALIC_FONT        3
  1060. #define                    MODERN_FONT        4
  1061. #define                    TYPEWRITER_FONT        5
  1062. X            int            size;    /* point size */
  1063. X            int            color;
  1064. X            int            depth;
  1065. X            float            angle;    /* in radian */
  1066. X            int            style;
  1067. #define                    PLAIN        1
  1068. #define                    ITALIC        2
  1069. #define                    BOLD        4
  1070. #define                    OUTLINE        8
  1071. #define                    SHADOW        16
  1072. X            int            height;    /* pixels */
  1073. X            int            length;    /* pixels */
  1074. X            int            base_x;
  1075. X            int            base_y;
  1076. X            struct f_pen        *pen;
  1077. X            char            *cstring;
  1078. X            struct f_text        *next;
  1079. X            }
  1080. X        F_text;
  1081. X
  1082. typedef        struct f_control {
  1083. X            float            lx, ly, rx, ry;
  1084. X            struct f_control    *next;
  1085. X            }
  1086. X        F_control;
  1087. X
  1088. #define        int_spline(s)        (s->type & 0x2)
  1089. #define        normal_spline(s)    (!(s->type & 0x2))
  1090. #define        closed_spline(s)    (s->type & 0x1)
  1091. #define        open_spline(s)        (!(s->type & 0x1))
  1092. X
  1093. typedef        struct f_spline {
  1094. X            int            type;
  1095. #define                    T_OPEN_NORMAL        0
  1096. #define                    T_CLOSED_NORMAL        1
  1097. #define                    T_OPEN_INTERPOLATED    2
  1098. #define                    T_CLOSED_INTERPOLATED    3
  1099. X            int            style;
  1100. X            int            thickness;
  1101. X            int            color;
  1102. X            int            depth;
  1103. X            float            style_val;
  1104. X            struct f_pen        *pen;
  1105. X            struct f_pattern    *area_fill;
  1106. X            struct f_arrow        *for_arrow;
  1107. X            struct f_arrow        *back_arrow;
  1108. X            /*
  1109. X            For T_OPEN_NORMAL and T_CLOSED_NORMAL points
  1110. X            are control points while they are knots for
  1111. X            T_OPEN_INTERPOLATED and T_CLOSED_INTERPOLTED
  1112. X            whose control points are stored in controls.
  1113. X            */
  1114. X            struct f_point        *points;
  1115. X            struct f_control    *controls;
  1116. X            struct f_spline        *next;
  1117. X            }
  1118. X        F_spline;
  1119. X
  1120. typedef        struct f_compound {
  1121. X            struct f_pos        nwcorner;
  1122. X            struct f_pos        secorner;
  1123. X            struct f_line        *lines;
  1124. X            struct f_ellipse    *ellipses;
  1125. X            struct f_spline        *splines;
  1126. X            struct f_text        *texts;
  1127. X            struct f_arc        *arcs;
  1128. X            struct f_compound    *compounds;
  1129. X            struct f_compound    *next;
  1130. X            }
  1131. X        F_compound;
  1132. X
  1133. #define        ARROW_SIZE        sizeof(struct f_arrow)
  1134. #define        POINT_SIZE        sizeof(struct f_point)
  1135. #define        CONTROL_SIZE        sizeof(struct f_control)
  1136. #define        ELLOBJ_SIZE        sizeof(struct f_ellipse)
  1137. #define        ARCOBJ_SIZE        sizeof(struct f_arc)
  1138. #define        LINOBJ_SIZE        sizeof(struct f_line)
  1139. #define        TEXOBJ_SIZE        sizeof(struct f_text)
  1140. #define        SPLOBJ_SIZE        sizeof(struct f_spline)
  1141. #define        COMOBJ_SIZE        sizeof(struct f_compound)
  1142. X
  1143. /**********************  object codes  **********************/
  1144. X
  1145. #define        O_ELLIPSE        1
  1146. #define        O_POLYLINE        2
  1147. #define        O_SPLINE        3
  1148. #define        O_TEXT            4
  1149. #define        O_ARC            5
  1150. #define        O_COMPOUND        6
  1151. #define        O_END_COMPOUND        -O_COMPOUND
  1152. #define        O_ALL_OBJECT        99
  1153. X
  1154. /************  object styles (except for f_text)  ************/
  1155. X
  1156. #define        SOLID_LINE        0
  1157. #define        DASH_LINE        1
  1158. #define        DOTTED_LINE        2
  1159. X
  1160. #define        CLOSED_PATH        0
  1161. #define        OPEN_PATH        1
  1162. SHAR_EOF
  1163. chmod 0666 gnuplot/term/object.h ||
  1164. echo 'restore of gnuplot/term/object.h failed'
  1165. Wc_c="`wc -c < 'gnuplot/term/object.h'`"
  1166. test 5063 -eq "$Wc_c" ||
  1167.     echo 'gnuplot/term/object.h: original size 5063, current size' "$Wc_c"
  1168. rm -f _shar_wnt_.tmp
  1169. fi
  1170. # ============= gnuplot/term/post.trm ==============
  1171. if test -f 'gnuplot/term/post.trm' -a X"$1" != X"-c"; then
  1172.     echo 'x - skipping gnuplot/term/post.trm (File already exists)'
  1173.     rm -f _shar_wnt_.tmp
  1174. else
  1175. > _shar_wnt_.tmp
  1176. echo 'x - extracting gnuplot/term/post.trm (Text)'
  1177. sed 's/^X//' << 'SHAR_EOF' > 'gnuplot/term/post.trm' &&
  1178. /* GNUPLOT - post.trm */
  1179. /*
  1180. X * Copyright (C) 1990   
  1181. X *
  1182. X * Permission to use, copy, and distribute this software and its
  1183. X * documentation for any purpose with or without fee is hereby granted, 
  1184. X * provided that the above copyright notice appear in all copies and 
  1185. X * that both that copyright notice and this permission notice appear 
  1186. X * in supporting documentation.
  1187. X *
  1188. X * Permission to modify the software is granted, but not the right to
  1189. X * distribute the modified code.  Modifications are to be distributed 
  1190. X * as patches to released version.
  1191. X *  
  1192. X * This software  is provided "as is" without express or implied warranty.
  1193. X * 
  1194. X * This file is included by ../term.c.
  1195. X *
  1196. X * This terminal driver supports:
  1197. X *     postscript
  1198. X *
  1199. X * AUTHORS
  1200. X *  Russell Lang
  1201. X * 
  1202. X * send your comments or suggestions to (pixar!info-gnuplot@sun.com).
  1203. X *
  1204. X * The 'postscript' driver produces landscape output 10" wide and 7" high.  
  1205. X * To get a smaller epsf output use 'set size 0.5,0.5', 
  1206. X * 'set term postscript portrait', make only one plot per file
  1207. X * and change the first line of the postscript file from
  1208. X * '%!PS-Adobe-2.0' to '%!PS-Adobe-2.0 EPSF-2.0'
  1209. X * To change font to Times-Roman and font size to 20pts use 
  1210. X * 'set term postscript "Times-Roman" 20'.
  1211. X */
  1212. X
  1213. X
  1214. /* PostScript driver by Russell Lang, rjl@monu1.cc.monash.edu.au */
  1215. X
  1216. char ps_font[MAX_ID_LEN+1] = "Courier" ; /* name of font */
  1217. int ps_fontsize = 14;                     /* size of font in pts */
  1218. BOOLEAN ps_portrait = FALSE;                 /* vertical page */
  1219. BOOLEAN ps_color = FALSE;
  1220. int ps_page=0;            /* page count */
  1221. int ps_path_count=0;     /* count of lines in path */
  1222. int ps_ang=0;            /* text angle */
  1223. enum JUSTIFY ps_justify=LEFT;    /* text is flush left */
  1224. X
  1225. char *PS_header[] = {
  1226. "/vpt2 vpt 2 mul def\n",
  1227. "/hpt2 hpt 2 mul def\n",
  1228. /* flush left show */
  1229. "/Lshow { currentpoint stroke moveto\n",
  1230. "  0 vshift rmoveto show } def\n", 
  1231. /* flush right show */
  1232. "/Rshow { currentpoint stroke moveto\n",
  1233. "  dup stringwidth pop neg vshift rmoveto show } def\n", 
  1234. /* centred show */
  1235. "/Cshow { currentpoint stroke moveto\n",
  1236. "  dup stringwidth pop -2 div vshift rmoveto show } def\n", 
  1237. /* Dash or Color Line */
  1238. "/DL { Color {setrgbcolor [] 0 setdash pop}\n",
  1239. " {pop pop pop 0 setdash} ifelse } def\n",
  1240. /* Border Lines */
  1241. "/BL { stroke gnulinewidth 2 mul setlinewidth } def\n",
  1242. /* Axes Lines */
  1243. "/AL { stroke gnulinewidth 2 div setlinewidth } def\n",
  1244. /* Plot Lines */
  1245. "/PL { stroke gnulinewidth setlinewidth } def\n",
  1246. /* Line Types */
  1247. "/LTb { BL [] 0 0 0 DL } def\n", /* border */
  1248. "/LTa { AL [1 dl 2 dl] 0 setdash 0 0 0 setrgbcolor } def\n", /* axes */
  1249. "/LT0 { PL [] 0 1 0 DL } def\n",
  1250. "/LT1 { PL [4 dl 2 dl] 0 0 1 DL } def\n",
  1251. "/LT2 { PL [2 dl 3 dl] 1 0 0 DL } def\n",
  1252. "/LT3 { PL [1 dl 1.5 dl] 1 0 1 DL } def\n",
  1253. "/LT4 { PL [5 dl 2 dl 1 dl 2 dl] 0 1 1 DL } def\n",
  1254. "/LT5 { PL [4 dl 3 dl 1 dl 3 dl] 1 1 0 DL } def\n",
  1255. "/LT6 { PL [2 dl 2 dl 2 dl 4 dl] 0 0 0 DL } def\n",
  1256. "/LT7 { PL [2 dl 2 dl 2 dl 2 dl 2 dl 4 dl] 1 0.3 0 DL } def\n",
  1257. "/LT8 { PL [2 dl 2 dl 2 dl 2 dl 2 dl 2 dl 2 dl 4 dl] 0.5 0.5 0.5 DL } def\n",
  1258. "/M {moveto} def\n",
  1259. "/L {lineto} def\n",
  1260. "/P { stroke [] 0 setdash\n", /* Point */
  1261. "  currentlinewidth 2 div sub moveto\n",
  1262. "  0 currentlinewidth rlineto  stroke } def\n",
  1263. "/D { stroke [] 0 setdash  2 copy  vpt add moveto\n", /* Diamond */
  1264. "  hpt neg vpt neg rlineto  hpt vpt neg rlineto\n",
  1265. "  hpt vpt rlineto  hpt neg vpt rlineto  closepath  stroke\n",
  1266. "  P  } def\n",
  1267. "/A { stroke [] 0 setdash  vpt sub moveto  0 vpt2 rlineto\n", /* Plus (Add) */
  1268. "  currentpoint stroke moveto\n",
  1269. "  hpt neg vpt neg rmoveto  hpt2 0 rlineto stroke\n",
  1270. "  } def\n",
  1271. "/B { stroke [] 0 setdash  2 copy  exch hpt sub exch vpt add moveto\n", /* Box */
  1272. "  0 vpt2 neg rlineto  hpt2 0 rlineto  0 vpt2 rlineto\n",
  1273. "  hpt2 neg 0 rlineto  closepath  stroke\n",
  1274. "  P  } def\n",
  1275. "/C { stroke [] 0 setdash  exch hpt sub exch vpt add moveto\n", /* Cross */
  1276. "  hpt2 vpt2 neg rlineto  currentpoint  stroke  moveto\n",
  1277. "  hpt2 neg 0 rmoveto  hpt2 vpt2 rlineto stroke  } def\n",
  1278. "/T { stroke [] 0 setdash  2 copy  vpt 1.12 mul add moveto\n", /* Triangle */
  1279. "  hpt neg vpt -1.62 mul rlineto\n",
  1280. "  hpt 2 mul 0 rlineto\n",
  1281. "  hpt neg vpt 1.62 mul rlineto  closepath  stroke\n",
  1282. "  P  } def\n",
  1283. "/S { 2 copy A C} def\n", /* Star */
  1284. NULL
  1285. };
  1286. X
  1287. #define PS_XOFF    50    /* page offset in pts */
  1288. #define PS_YOFF    50
  1289. X
  1290. #define PS_XMAX 7200
  1291. #define PS_YMAX 5040
  1292. X
  1293. #define PS_XLAST (PS_XMAX - 1)
  1294. #define PS_YLAST (PS_YMAX - 1)
  1295. X
  1296. #define PS_VTIC (PS_YMAX/80)
  1297. #define PS_HTIC (PS_YMAX/80)
  1298. X
  1299. #define PS_SC (10)                /* scale is 1pt = 10 units */
  1300. #define    PS_LW (0.5*PS_SC)        /* linewidth = 0.5 pts */
  1301. X
  1302. #define PS_VCHAR (14*PS_SC)        /* default is 14 point characters */
  1303. #define PS_HCHAR (14*PS_SC*6/10)
  1304. X
  1305. X
  1306. PS_options()
  1307. {
  1308. X    extern struct value *const_express();
  1309. X    extern double real();
  1310. X
  1311. X    if (!END_OF_COMMAND) {
  1312. X        if (almost_equals(c_token,"p$ortrait")) {
  1313. X            ps_portrait=TRUE;
  1314. X            c_token++;
  1315. X        }
  1316. X        else if (almost_equals(c_token,"l$andscape")) {
  1317. X            ps_portrait=FALSE;
  1318. X            c_token++;
  1319. X        }
  1320. X        else if (almost_equals(c_token,"d$efault")) {
  1321. X            ps_portrait=FALSE;
  1322. X            ps_color=FALSE;
  1323. X            strcpy(ps_font,"Courier");
  1324. X            ps_fontsize = 14;
  1325. X            c_token++;
  1326. X        }
  1327. X    }
  1328. X
  1329. X    if (!END_OF_COMMAND) {
  1330. X        if (almost_equals(c_token,"m$onochrome")) {
  1331. X            ps_color=FALSE;
  1332. X            c_token++;
  1333. X        }
  1334. X        else if (almost_equals(c_token,"c$olor")) {
  1335. X            ps_color=TRUE;
  1336. X            c_token++;
  1337. X        }
  1338. X    }
  1339. X
  1340. X    if (!END_OF_COMMAND && isstring(c_token)) {
  1341. X        quote_str(ps_font,c_token);
  1342. X        c_token++;
  1343. X    }
  1344. X
  1345. X    if (!END_OF_COMMAND) {
  1346. X        /* We have font size specified */
  1347. X        struct value a;
  1348. X        ps_fontsize = (int)real(const_express(&a));
  1349. X        c_token++;
  1350. X        term_tbl[term].v_char = (unsigned int)(ps_fontsize*PS_SC);
  1351. X        term_tbl[term].h_char = (unsigned int)(ps_fontsize*PS_SC*6/10);
  1352. X    }
  1353. X
  1354. X    sprintf(term_options,"%s %s \"%s\" %d",
  1355. X        ps_portrait ? "portrait" : "landscape",
  1356. X        ps_color ? "color" : "monochrome",ps_font,ps_fontsize);
  1357. }
  1358. X
  1359. X
  1360. PS_init()
  1361. {
  1362. struct termentry *t = &term_tbl[term];
  1363. int i;
  1364. X    ps_page = 0;
  1365. X    fprintf(outfile,"%%!PS-Adobe-2.0\n");
  1366. X    fprintf(outfile,"%%%%Creator: gnuplot\n");
  1367. X    fprintf(outfile,"%%%%DocumentFonts: %s\n", ps_font);
  1368. X    fprintf(outfile,"%%%%BoundingBox: %d %d ", PS_XOFF,PS_YOFF);
  1369. X    if (ps_portrait)
  1370. X        fprintf(outfile,"%d %d\n", 
  1371. X            (int)(xsize*(PS_XMAX)/PS_SC+0.5+PS_XOFF), 
  1372. X            (int)(ysize*(PS_YMAX)/PS_SC+0.5+PS_YOFF) );
  1373. X    else 
  1374. X        fprintf(outfile,"%d %d\n", 
  1375. X            (int)(ysize*(PS_YMAX)/PS_SC+0.5+PS_XOFF), 
  1376. X            (int)(xsize*(PS_XMAX)/PS_SC+0.5+PS_YOFF) );
  1377. X    fprintf(outfile,"%%%%Pages: (atend)\n");
  1378. X    fprintf(outfile,"%%%%EndComments\n");
  1379. X    fprintf(outfile,"/gnudict 40 dict def\ngnudict begin\n");
  1380. X    fprintf(outfile,"/Color %s def\n",ps_color ? "true" : "false");
  1381. X    fprintf(outfile,"/gnulinewidth %.3f def\n",PS_LW);
  1382. X    fprintf(outfile,"/vshift %d def\n", (int)(t->v_char)/(-3));
  1383. X    fprintf(outfile,"/dl {%d mul} def\n",PS_SC); /* dash length */
  1384. X    fprintf(outfile,"/hpt %.1f def\n",PS_HTIC/2.0);
  1385. X    fprintf(outfile,"/vpt %.1f def\n",PS_VTIC/2.0);
  1386. X    for ( i=0; PS_header[i] != NULL; i++)
  1387. X        fprintf(outfile,"%s",PS_header[i]);
  1388. X    fprintf(outfile,"end\n");
  1389. X    fprintf(outfile,"%%%%EndProlog\n");
  1390. }
  1391. X
  1392. X
  1393. PS_graphics()
  1394. {
  1395. struct termentry *t = &term_tbl[term];
  1396. X    ps_page++;
  1397. X    fprintf(outfile,"%%%%Page: %d %d\n",ps_page,ps_page);
  1398. X    fprintf(outfile,"gnudict begin\n");
  1399. X    fprintf(outfile,"gsave\n");
  1400. X    fprintf(outfile,"%d %d translate\n",PS_XOFF,PS_YOFF);
  1401. X    if (ps_portrait) {
  1402. X        fprintf(outfile,"%.3f %.3f scale\n", xsize/PS_SC, ysize/PS_SC);
  1403. X    }
  1404. X    else {
  1405. X        fprintf(outfile,"%.3f %.3f scale\n", ysize/PS_SC, xsize/PS_SC);
  1406. X        fprintf(outfile,"90 rotate\n0 %d translate\n", -PS_YMAX);
  1407. X    }
  1408. X    fprintf(outfile,"0 setgray\n");
  1409. X    fprintf(outfile,"/%s findfont %d ", ps_font, (t->v_char) );
  1410. X    fprintf(outfile,"scalefont setfont\n");
  1411. X    fprintf(outfile,"newpath\n");
  1412. X    ps_path_count = 0;
  1413. }
  1414. X
  1415. X
  1416. PS_text()
  1417. {
  1418. X    ps_path_count = 0;
  1419. X    fprintf(outfile,"stroke\ngrestore\nend\nshowpage\n");
  1420. }
  1421. X
  1422. X
  1423. PS_reset()
  1424. {
  1425. X    fprintf(outfile,"%%%%Trailer\n");
  1426. X    fprintf(outfile,"%%%%Pages: %d\n",ps_page);
  1427. }
  1428. X
  1429. X
  1430. PS_linetype(linetype)
  1431. int linetype;
  1432. {
  1433. char *line = "ba012345678"; 
  1434. X    fprintf(outfile,"LT%c\n", line[(linetype%9)+2]);
  1435. X    ps_path_count = 0;
  1436. }
  1437. X
  1438. X
  1439. PS_move(x,y)
  1440. unsigned int x,y;
  1441. {
  1442. X    fprintf(outfile,"%d %d M\n", x, y);
  1443. X    ps_path_count += 1;
  1444. }
  1445. X
  1446. X
  1447. PS_vector(x,y)
  1448. unsigned int x,y;
  1449. {
  1450. X    fprintf(outfile,"%d %d L\n", x, y);
  1451. X    ps_path_count += 1;
  1452. X    if (ps_path_count >= 400) {
  1453. X        fprintf(outfile,"currentpoint stroke moveto\n");
  1454. X        ps_path_count = 0;
  1455. X    }
  1456. }
  1457. X
  1458. X
  1459. PS_put_text(x,y,str)
  1460. unsigned int x, y;
  1461. char *str;
  1462. {
  1463. char ch;
  1464. X    PS_move(x,y);
  1465. X    if (ps_ang != 0)
  1466. X        fprintf(outfile,"currentpoint gsave translate %d rotate 0 0 moveto\n"
  1467. X            ,ps_ang*90);
  1468. X    putc('(',outfile);
  1469. X    ch = *str++;
  1470. X    while(ch!='\0') {
  1471. X        if ( (ch=='(') || (ch==')') || (ch=='\\') )
  1472. X            putc('\\',outfile);
  1473. X        putc(ch,outfile);
  1474. X        ch = *str++;
  1475. X    }
  1476. X    switch(ps_justify) {
  1477. X        case LEFT : fprintf(outfile,") Lshow\n");
  1478. X            break;
  1479. X        case CENTRE : fprintf(outfile,") Cshow\n");
  1480. X            break;
  1481. X        case RIGHT : fprintf(outfile,") Rshow\n");
  1482. X            break;
  1483. X    }
  1484. X    if (ps_ang != 0)
  1485. X        fprintf(outfile,"grestore\n");
  1486. X    ps_path_count = 0;
  1487. }
  1488. X
  1489. int PS_text_angle(ang)
  1490. int ang;
  1491. {
  1492. X    ps_ang=ang;
  1493. X    return TRUE;
  1494. }
  1495. X
  1496. int PS_justify_text(mode)
  1497. enum JUSTIFY mode;
  1498. {
  1499. X    ps_justify=mode;
  1500. X    return TRUE;
  1501. }
  1502. X
  1503. /* postscript point routines */
  1504. PS_point(x,y,number)
  1505. int x,y;
  1506. int number;
  1507. {
  1508. char *point = "PDABCTS";
  1509. X    number %= POINT_TYPES;
  1510. X     if (number < -1)
  1511. X        number = -1;        /* negative types are all 'dot' */
  1512. X    fprintf(outfile,"%d %d %c\n", x, y, point[number+1]);
  1513. X    ps_path_count = 0;
  1514. }
  1515. X
  1516. SHAR_EOF
  1517. chmod 0644 gnuplot/term/post.trm ||
  1518. echo 'restore of gnuplot/term/post.trm failed'
  1519. Wc_c="`wc -c < 'gnuplot/term/post.trm'`"
  1520. test 9281 -eq "$Wc_c" ||
  1521.     echo 'gnuplot/term/post.trm: original size 9281, current size' "$Wc_c"
  1522. rm -f _shar_wnt_.tmp
  1523. fi
  1524. # ============= gnuplot/term/dxf.trm ==============
  1525. if test -f 'gnuplot/term/dxf.trm' -a X"$1" != X"-c"; then
  1526.     echo 'x - skipping gnuplot/term/dxf.trm (File already exists)'
  1527.     rm -f _shar_wnt_.tmp
  1528. else
  1529. > _shar_wnt_.tmp
  1530. echo 'x - extracting gnuplot/term/dxf.trm (Text)'
  1531. sed 's/^X//' << 'SHAR_EOF' > 'gnuplot/term/dxf.trm' &&
  1532. /* GNUPLOT - dxf.trm */
  1533. /*
  1534. X * Copyright (C) 1991
  1535. X *
  1536. X * Permission to use, copy, and distribute this software and its
  1537. X * documentation for any purpose with or without fee is hereby granted,
  1538. X * provided that the above copyright notice appear in all copies and
  1539. X * that both that copyright notice and this permission notice appear
  1540. X * in supporting documentation.
  1541. X *
  1542. X * Permission to modify the software is granted, but not the right to
  1543. X * distribute the modified code.  Modifications are to be distributed
  1544. X * as patches to released version.
  1545. X *
  1546. X * This software  is provided "as is" without express or implied warranty.
  1547. X *
  1548. X * This file is included by ../term.c.
  1549. X *
  1550. X * This terminal driver supports:
  1551. X *   AutoCad (Release 10.x) dxf file format (import with AutoCad dxfin command)
  1552. X *
  1553. X *
  1554. X * AUTHOR
  1555. X *   Florian Hiss  (fhis1231@w204zrz.zrz.tu-berlin.de)
  1556. X *
  1557. X * send your comments or suggestions to (pixar!info-gnuplot@sun.com).
  1558. */
  1559. X
  1560. #define DXF_UNIT 60.0
  1561. #define LINEWIDTH 0.0351  /* default line width is 1 pt */
  1562. X
  1563. /* 120 (autocad units) wide by 80 (autocad units) high (default)
  1564. X   use the GNUPLOT 'set size' command to change the defaults */
  1565. #define DXF_XMAX (120.0 * DXF_UNIT)
  1566. #define DXF_YMAX (80.0 * DXF_UNIT)
  1567. #define DXF_HTIC (0.01 * DXF_XMAX)  /* 1.0 percent */
  1568. #define DXF_VTIC (0.01 * DXF_YMAX)  /* 1.0 percent */
  1569. #define DXF_HCHAR (0.014 * DXF_XMAX) /* 1.4 percent */
  1570. #define DXF_VCHAR (0.026 * DXF_YMAX) /* 2.6 percent */
  1571. #define DXF_TEXTHEIGHT (0.7 * DXF_VCHAR) /* actual text height */
  1572. #define DXF_TEXTWIDTH (0.7 * DXF_HCHAR) /* actual text width,
  1573. X only a guess, we don't know the width of a character of given height
  1574. X of the AutoCad STANDARD text font, so change it if you like */
  1575. #define DXF_LINE_TYPES 7 /* number of line types we support. see below  */
  1576. #define MAX_LAYER 7  /* number of layers used for the drawing. see below */
  1577. #define LT_SCALE 1  /* line type scaling */
  1578. X
  1579. static unsigned int DXF_posx;
  1580. static unsigned int DXF_posy;
  1581. static unsigned int dxf_linetype; /* linetype is mapped to a layer. see below. */
  1582. enum JUSTIFY dxf_justify = LEFT;
  1583. static float dxf_angle = 0.0; /* either 0 (horizontal) or 90.0 (vertical) */
  1584. X
  1585. /* text style used in the entire drawing */
  1586. static char *text_style = "STANDARD";
  1587. /* text always resides on layer 0 */
  1588. #define TEXT_LAYER 0
  1589. /* each linetype resides on its own layer. each layer has its own color.
  1590. X   this avoids difficulties that AutoCad has with proper scaling of
  1591. X   the linetypes.
  1592. X   change the colors according to your needs */
  1593. static char *layer_name[] = {"0","1","2","3","4","5","6"};
  1594. /* the colours are white, red, yellow, green, cyan, blue, magenta.
  1595. X   change them according to your needs.
  1596. X   when using a black and white plotting device the colours map to different
  1597. X   line thicknesses. see description of AutoCad print / plot command */
  1598. static char *layer_colour[] = {"7","1","2","3","4","5","6"};
  1599. /* support line types AutoCad has to offer by default. */
  1600. static char *layer_lines[] = {"CONTINUOUS","DASHED","HIDDEN","CENTER","PHANTOM",
  1601. X                "DOT","DASHDOT"};
  1602. X
  1603. static BOOLEAN vector_was_last = FALSE;
  1604. X
  1605. DXF_init()
  1606. {
  1607. X    DXF_posx = DXF_posy = 0;
  1608. X    dxf_linetype = 0;
  1609. X    dxf_angle = 0.0;
  1610. X    vector_was_last = FALSE;
  1611. }
  1612. X
  1613. DXF_graphics()
  1614. {
  1615. X    register struct termentry *t = &term_tbl[term];
  1616. X    int i;
  1617. X
  1618. X    fprintf(outfile,"999\n");
  1619. X    fprintf(outfile,"%% GNUPLOT: dxf file for AutoCad\n");
  1620. X    fprintf(outfile,"  0\nSECTION\n  2\nHEADER\n");
  1621. X    fprintf(outfile,"  9\n$EXTMIN\n");
  1622. X    fprintf(outfile," 10\n0.000\n 20\n0.000\n");
  1623. X    fprintf(outfile,"  9\n$EXTMAX\n");
  1624. X    fprintf(outfile," 10\n%-6.3f\n 20\n%-6.3f\n",t->xmax/DXF_UNIT,t->ymax/DXF_UNIT);
  1625. X    fprintf(outfile,"  9\n$LIMMIN\n");
  1626. X    fprintf(outfile," 10\n0.000\n 20\n0.000\n");
  1627. X    fprintf(outfile,"  9\n$LIMMAX\n");
  1628. X    fprintf(outfile," 10\n%-6.3f\n 20\n%-6.3f\n",t->xmax/DXF_UNIT,t->ymax/DXF_UNIT);
  1629. X    fprintf(outfile,"  9\n$TEXTSTYLE\n  7\n%s\n",text_style);
  1630. X    fprintf(outfile,"  9\n$TEXTSIZE\n 40\n%-6.3f\n",DXF_TEXTHEIGHT/DXF_UNIT);
  1631. X    fprintf(outfile,"  9\n$PLINEWID\n 40\n%-6.4f\n",LINEWIDTH);
  1632. X    fprintf(outfile,"  9\n$LTSCALE\n  40\n%-6.3f\n",LT_SCALE);
  1633. X    fprintf(outfile,"  9\n$COORDS\n 70\n  1\n");
  1634. X    fprintf(outfile,"  9\n$CELTYPE\n 6\nBYLAYER\n"); /* entity line type name */
  1635. X    fprintf(outfile,"  9\n$CLAYER\n  8\n0\n"); /* current layer */
  1636. X    fprintf(outfile,"  9\n$CECOLOR\n 62\n   %s\n",layer_colour[0]);
  1637. X    fprintf(outfile,"  9\n$MENU\n  1\nacad\n");
  1638. X    fprintf(outfile,"  0\nENDSEC\n");
  1639. X    fprintf(outfile,"  0\nSECTION\n  2\nTABLES\n");
  1640. X    /* the linetype table */
  1641. X    fprintf(outfile,"0\nTABLE\n  2\nLTYPE\n 70\n    %d\n",DXF_LINE_TYPES);
  1642. X    fprintf(outfile,"0\nLTYPE\n  2\nCONTINUOUS\n 70\n    64\n");
  1643. X    fprintf(outfile,"  3\nSolid line\n 72\n    65\n 73\n      0\n 40\n0.0\n");
  1644. X    fprintf(outfile,"  0\nLTYPE\n  2\nDASHED\n 70\n    64\n");
  1645. X    fprintf(outfile,"  3\n__ __ __ __ __ __ __ __ __ __ __ __ __ __ __\n");
  1646. X    fprintf(outfile," 72\n    65\n 73\n     2\n 40\n0.75\n 49\n0.5\n 49\n-0.25\n");
  1647. X    fprintf(outfile,"  0\nLTYPE\n  2\nHIDDEN\n 70\n    64\n");
  1648. X    fprintf(outfile,"  3\n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _\n");
  1649. X    fprintf(outfile," 72\n    65\n 73\n     2\n 40\n0.375\n 49\n0.25\n 49\n-0.125\n");
  1650. X    fprintf(outfile,"  0\nLTYPE\n  2\nCENTER\n 70\n    64\n");
  1651. X    fprintf(outfile,"  3\n____ _ ____ _ ____ _ ____ _ ____ _ ____ _ ____\n");
  1652. X    fprintf(outfile," 72\n    65\n 73\n     4\n 40\n2.0\n 49\n1.25\n 49\n-0.25\n");
  1653. X    fprintf(outfile," 49\n0.25\n 49\n-0.25\n");
  1654. X    fprintf(outfile,"  0\nLTYPE\n  2\nPHANTOM\n 70\n    64\n");
  1655. X    fprintf(outfile,"  3\n_____ _ _ _____ _ _ _____ _ _ _____ _ _ ____\n");
  1656. X    fprintf(outfile," 72\n    65\n 73\n     6\n 40\n2.5\n 49\n1.25\n");
  1657. X    fprintf(outfile," 49\n-0.25\n 49\n0.25\n 49\n-0.25\n 49\n0.25\n 49\n-0.25\n");
  1658. X    fprintf(outfile,"  0\nLTYPE\n  2\nDOT\n 70\n    64\n");
  1659. X    fprintf(outfile,"  3\n...............................................\n");
  1660. X    fprintf(outfile," 72\n    65\n 73\n     2\n 40\n0.25\n 49\n0.0\n 49\n-0.25\n");
  1661. X    fprintf(outfile,"  0\nLTYPE\n  2\nDASHDOT\n 70\n    64\n");
  1662. X    fprintf(outfile,"  3\n__ . __ . __ . __ . __ . __ . __ . __ . __ . __\n");
  1663. X    fprintf(outfile," 72\n    65\n 73\n     4\n 40\n1.0\n 49\n0.5\n 49\n-0.25\n");
  1664. X    fprintf(outfile," 49\n0.0\n 49\n-0.25\n");
  1665. X    fprintf(outfile,"  0\nENDTAB\n");
  1666. X    /* the layer table */
  1667. X    fprintf(outfile,"  0\nTABLE\n  2\nLAYER\n 70\n   %-d\n",MAX_LAYER);
  1668. X    for (i = 1; i <= MAX_LAYER; i++)
  1669. X        fprintf(outfile,"  0\nLAYER\n  2\n%s\n 70\n   64\n62\n   %s\n  6\n%s\n",
  1670. X            layer_name[i-1],layer_colour[i-1],layer_lines[i-1]);
  1671. X    fprintf(outfile,"  0\nENDTAB\n0\nENDSEC\n");
  1672. X    /* no blocks for insertion */
  1673. X    fprintf(outfile,"  0\nSECTION\n  2\nBLOCKS\n  0\nENDSEC\n");
  1674. X    /* start the entity section */
  1675. X    fprintf(outfile,"  0\nSECTION\n");
  1676. X    fprintf(outfile,"  2\nENTITIES\n");
  1677. }
  1678. X
  1679. DXF_text()
  1680. {
  1681. X    if (vector_was_last) fprintf(outfile,"  0\nSEQEND\n");
  1682. X    fprintf(outfile,"  0\nENDSEC\n  0\nEOF\n");
  1683. }
  1684. X
  1685. DXF_linetype(linetype)
  1686. X    int linetype;
  1687. {
  1688. X    linetype = abs(linetype);
  1689. X    linetype = linetype%DXF_LINE_TYPES;
  1690. X    dxf_linetype = linetype;
  1691. }
  1692. X
  1693. DXF_move(x, y)
  1694. X    unsigned int x, y;
  1695. {
  1696. X    DXF_posx = x;
  1697. X    DXF_posy = y;
  1698. X    if (vector_was_last) fprintf(outfile,"  0\nSEQEND\n");
  1699. X    vector_was_last = FALSE;
  1700. X    fprintf(outfile,"  0\nPOLYLINE\n  8\n%s\n 66\n   1\n",layer_name[dxf_linetype]);
  1701. X    fprintf(outfile,"  6\n%s\n",layer_lines[dxf_linetype]);
  1702. X    fprintf(outfile,"  0\nVERTEX\n  8\n%s\n",layer_name[dxf_linetype]);
  1703. X    fprintf(outfile,"  6\n%s\n",layer_lines[dxf_linetype]);
  1704. X    fprintf(outfile," 10\n%-6.3f\n 20\n%-6.3f\n 30\n0.000\n",DXF_posx/DXF_UNIT,DXF_posy/DXF_UNIT);
  1705. }
  1706. X
  1707. DXF_vector(ux, uy)
  1708. X    unsigned int ux, uy;
  1709. {
  1710. X    DXF_posx = ux;
  1711. X    DXF_posy = uy;
  1712. X    vector_was_last = TRUE;
  1713. X    fprintf(outfile,"  0\nVERTEX\n  8\n%s\n",layer_name[dxf_linetype]);
  1714. X    fprintf(outfile,"  6\n%s\n",layer_lines[dxf_linetype]);
  1715. X    fprintf(outfile,"  10\n%-6.3f\n  20\n%-6.3f\n  30\n0.000\n",
  1716. X                    DXF_posx/DXF_UNIT,DXF_posy/DXF_UNIT);
  1717. }
  1718. X
  1719. DXF_put_text(x, y, str)
  1720. X    int x, y;
  1721. X    char str[];
  1722. {
  1723. X    int stl;
  1724. X    float xleftpos, yleftpos, xrightpos,yrightpos;
  1725. X    /* ignore empty strings */
  1726. X    if (str[0] == '\0') return;
  1727. SHAR_EOF
  1728. true || echo 'restore of gnuplot/term/dxf.trm failed'
  1729. fi
  1730. echo 'End of  part 17'
  1731. echo 'File gnuplot/term/dxf.trm is continued in part 18'
  1732. echo 18 > _shar_seq_.tmp
  1733. exit 0
  1734.  
  1735. exit 0 # Just in case...
  1736. -- 
  1737. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1738. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1739. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1740. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1741.