home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume23 / transfig / part02 < prev    next >
Internet Message Format  |  1991-06-19  |  47KB
  1. Path: j.cc.purdue.edu!mentor.cc.purdue.edu!noose.ecn.purdue.edu!samsung!zaphod.mps.ohio-state.edu!usc!apple!bbn.com!papaya.bbn.com!rsalz
  2. From: rsalz@bbn.com (Rich Salz)
  3. Newsgroups: comp.sources.unix
  4. Subject: v23i015:  Tools for creating TeX documents with portable graphics, Part02/06
  5. Message-ID: <2812@litchi.bbn.com>
  6. Date: 31 Aug 90 13:43:10 GMT
  7. Organization: BBN Systems and Technologies, Cambridge MA
  8. Lines: 1788
  9. Approved: rsalz@uunet.UU.NET
  10. X-Checksum-Snefru: 7343b6b4 9f1c53a2 a3af18c4 d4688d13
  11.  
  12. Submitted-by: Micah Beck <beck@cs.cornell.edu>
  13. Posting-number: Volume 23, Issue 15
  14. Archive-name: transfig/part02
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then unpack
  18. # it by saving it into a file and typing "sh file".  To overwrite existing
  19. # files, type "sh file -c".  You can also feed this as standard input via
  20. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  21. # will see the following message at the end:
  22. #        "End of archive 2 (of 6)."
  23. # Contents:  transfig/doc/fig2dev.1 transfig/fig2dev/bound.c
  24. #   transfig/fig2dev/fig2dev.c transfig/fig2dev/latex_line.c
  25. #   transfig/fig2dev/object.h transfig/fig2dev/read1_3.c
  26. # Wrapped by beck@rocky on Thu May 17 15:56:10 1990
  27. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  28. if test -f 'transfig/doc/fig2dev.1' -a "${1}" != "-c" ; then 
  29.   echo shar: Will not clobber existing file \"'transfig/doc/fig2dev.1'\"
  30. else
  31. echo shar: Extracting \"'transfig/doc/fig2dev.1'\" \(6038 characters\)
  32. sed "s/^X//" >'transfig/doc/fig2dev.1' <<'END_OF_FILE'
  33. X.TH FIG2DEV 1 "7 May 1989"
  34. X.SH NAME
  35. Xfig2dev \- translates Fig code to various graphics languages
  36. X
  37. X.SH SYNOPSIS
  38. X.B fig2dev
  39. X.B \-L
  40. X.I language
  41. X[
  42. X.B \-m
  43. X.I mag
  44. X] [
  45. X.B \-f 
  46. X.I font
  47. X] [
  48. X.B \-s
  49. X.I fsize
  50. X] [
  51. X.I other options
  52. X] [
  53. X\fIfig-file\fR [ \fIout-file\fR ] ]
  54. X
  55. X.SH DESCRIPTION
  56. X.I Fig2dev
  57. Xtranslates fig code in the named
  58. X.I fig-file
  59. Xinto the specified graphics 
  60. X.I language
  61. Xand puts them in
  62. X.I out-file.
  63. XThe default
  64. X.I fig-file
  65. Xand
  66. X.I out-file
  67. Xare standard input and standard output, respectively
  68. X.LP
  69. XFig (Facility for Interactive Generation of figures) is a screen-oriented
  70. Xtool which allows the user to draw and manipulate objects interactively.
  71. XVarious versions of Fig run under the Suntools/Sunview window environment
  72. Xand under version 11 of the X Windows System.
  73. XFig2dev is compatible with Fig versions 1.3, 1.4-TFX, and 2.0.
  74. X
  75. X.SH OPTIONS
  76. X.TP
  77. X.B \-L
  78. XSet the output graphics language.
  79. XValid languages are
  80. X\fBbox, epic, eepic, eepicemu, latex, null, pic, pictex,\fR
  81. Xand
  82. X.B ps.
  83. X.TP
  84. X.B \-m
  85. XSet the magnification at which the figure is rendered to
  86. X.I mag.
  87. XThe default is 1.0.
  88. X.TP
  89. X.B \-f 
  90. XSet the default font used for text objects to
  91. X.I font.
  92. XThe default is Roman; the format of this option depends on the graphics
  93. X.I language
  94. Xin use.
  95. XIn TeX-based languages, the font is the base of the name given in lfonts.tex,
  96. Xfor instance \"cmr\" for Roman, or \"tt\" for teletype.
  97. XIn PostScript, it is any font name known to the printer or interpreter.
  98. X.TP
  99. X.B \-s
  100. XSet the default font size (in points) for text objects to
  101. X.I fsize.
  102. XThe default is 11*mag, and thus is scaled by the \fB-m\fR option.
  103. XIf there is no scaling, the default font is eleven point Roman."
  104. X.TP
  105. X.I other options
  106. XThe other options are specific to the choice of graphics
  107. X.I language,
  108. Xas described below.
  109. X
  110. X.SH EPIC OPTIONS
  111. XEPIC is an enhancement to LaTeX picture drawing environment.
  112. XIt was developed by Sunil Podar of Department of Computer Science
  113. Xin S.U.N.Y at Stony Brook.
  114. X.LP
  115. XEEPIC is an extension to EPIC and LaTeX picture drawing environment
  116. Xwhich uses tpic specials as a graphics mechanism.
  117. XIt was written by Conrad Kwok of Division of
  118. XComputer Science at University of California, Davis.
  119. X.LP
  120. XEEPIC-EMU is an EEPIC emulation package which does not use tpic specials.
  121. X.TP
  122. X.B \-S
  123. XSet the scale to which the figure is rendered.
  124. XThis option automatically sets the 
  125. X.I magnification
  126. Xand size to
  127. X.I scale
  128. X/ 12 and 
  129. X.I scale
  130. Xrespectively.
  131. X.TP
  132. X.B \-l
  133. XUse "\fB\\thicklines\fR" when width of the line is wider than 
  134. X.I lwidth.
  135. XThe default is 2.
  136. X.TP
  137. X.B \-v
  138. XInclude comments in the output file.
  139. X.TP
  140. X.B \-P
  141. XGenerate a complete LaTeX file. In other words, the ouput file can be
  142. Xformatted without requiring any changes. The additional text inserted
  143. Xin the beginning and at the end of the file is controlled by the
  144. Xconfiguration parameter "Preamble" and "Postamble".
  145. X.TP
  146. X.B \-W
  147. XEnable variable line width
  148. X.TP
  149. X.B \-w
  150. XDisable variable line width. Only "\fB\\thicklines\fR" and/or
  151. X"\fB\\thinlines\fR" commands will be generated in the output file.
  152. X.LP
  153. XWhen variable line width option is enabled, "\fB\\thinlines\fR"
  154. Xcommand is still used when line width is less than
  155. X\fILineThick\fR. One potential problem is that the width of
  156. X"\fB\\thinlines\fR" is 0.4pt
  157. Xbut the resolution of Fig is 1/80 inch (approx. 1pt). If
  158. X\fILineThick\fR is set to 2, normal lines will be drawn in 0.4pt
  159. Xwide lines but the next line width is already 2pt. One possible
  160. Xsolution is to set \fILineThick\fR to 1 and set the width of the
  161. Xthose lines you want to be drawn in "\fB\\thinlines\fR"  to 0.
  162. X
  163. XDue to this problem, Varible line width \fIVarWidth\fR
  164. Xis defaulted to be false.
  165. X
  166. X.SH LATEX OPTIONS
  167. X.TP
  168. X.B \-l
  169. XSets the threshold between LaTeX thin and thick lines to 
  170. X.I lwidth
  171. Xpixels.
  172. XLaTeX supports only two different line width: \\thinlines and \\thicklines.
  173. XLines of width greater than
  174. X.I lwidth
  175. Xpixels are drawn as \\thicklines.
  176. XAlso affects the size of dots in dotted line style.
  177. XThe default is 0.
  178. X.TP
  179. X.B \-d
  180. XSet a seperate magnification for the length of line dashes to
  181. X.I dmag.
  182. X.TP
  183. X.B \-v
  184. XVerbose mode.
  185. X.LP
  186. XLaTeX cannot accurately represent all the graphics objects which can
  187. Xbe described by Fig.
  188. XFor example, the possible slopes which lines may have are limited.
  189. XSome objects, such as spline curves, cannot be drawn at all.
  190. XFig2latex chooses the closest possible line slope, and prints error
  191. Xmessages when objects cannot be drawn accurately
  192. X
  193. X.SH PICTEX OPTIONS
  194. X.B \-p 
  195. XSet the symbol used by PiCTeX for plotting lines and curves to 
  196. X.I psymbol.
  197. XThe default is "\fB\\sevrm .\fR"
  198. X.TP
  199. X.B \-l 
  200. XSet the width of any rules used to draw lines and boxes within the picture to 
  201. X.I lwidth.
  202. XThe default is "\fB0.7pt\fR".
  203. X.LP
  204. XIn order to include PiCTeX pictures into a document, it is necessary to
  205. Xload the PiCTeX macros.
  206. X.LP
  207. XPiCTeX uses TeX integer register arithmetic to generate curves,
  208. Xand so it is very slow.
  209. XPiCTeX draws curves by \fB\\put\fR-ing the \fIpsymbol\fR repeatedly,
  210. Xand so requires a large amount of TeX's internal memory,
  211. Xand generates large DVI files.
  212. XThe size of TeX's memory limits the number of plot symbols in a picture.
  213. XAs a result, it is best to use PiCTeX to generate small pictures.
  214. X
  215. X.SH POSTSCRIPT OPTIONS
  216. X.TP
  217. X.B -c
  218. Xoption centers the figure on the page.
  219. XThe centering may not be accurate if there are texts in the
  220. X.I fig_file
  221. Xthat extends too far to the right of other objects.
  222. X.TP
  223. X.B -P
  224. Xindicates that the figure describes a full page which will not
  225. Xnecessarily be inserted into a document, but can be sent directly
  226. Xto a PS printer.
  227. XThis ensures that a showpage command is inserted at the end of
  228. Xthe figure, and inhibits translation of the figure coordinate system.
  229. X.TP
  230. X.B -l
  231. XRotate figure to landscape mode.
  232. X
  233. X.SH "SEE ALSO"
  234. X[x]fig(1),
  235. Xpic(1)
  236. Xpic2fig(1),
  237. Xtransfig(1)
  238. X.SH AUTHORS
  239. XMicah Beck (beck@svax.cs.cornell.edu)
  240. X.br
  241. XCornell University
  242. X.br
  243. XMay 7 1989
  244. X.sp
  245. Xand Frank Schmuck (then of Cornell University)
  246. X.br
  247. Xand Conrad Kwok (then of the U.C. Davis).
  248. X.sp
  249. XModified from f2p (fig to PIC), by the author of Fig
  250. X.br
  251. XSupoj Sutanthavibul (supoj@sally.utexas.edu)
  252. X.br
  253. XUniversity of Texas at Austin. 
  254. X
  255. END_OF_FILE
  256. if test 6038 -ne `wc -c <'transfig/doc/fig2dev.1'`; then
  257.     echo shar: \"'transfig/doc/fig2dev.1'\" unpacked with wrong size!
  258. fi
  259. # end of 'transfig/doc/fig2dev.1'
  260. fi
  261. if test -f 'transfig/fig2dev/bound.c' -a "${1}" != "-c" ; then 
  262.   echo shar: Will not clobber existing file \"'transfig/fig2dev/bound.c'\"
  263. else
  264. echo shar: Extracting \"'transfig/fig2dev/bound.c'\" \(9753 characters\)
  265. sed "s/^X//" >'transfig/fig2dev/bound.c' <<'END_OF_FILE'
  266. X#include <stdio.h>
  267. X#include <math.h>
  268. X#include "pi.h"
  269. X#include "object.h"
  270. X
  271. X#define        Ninety_deg        M_PI_2
  272. X#define        One_eighty_deg        M_PI
  273. X#define        Two_seventy_deg        (M_PI + M_PI_2)
  274. X#define        Three_sixty_deg        (M_PI + M_PI)
  275. X#define        round(x)        ((int) ((x) + ((x >= 0)? 0.5: -0.5)))
  276. X#define        half(z1 ,z2)        ((z1+z2)/2.0)
  277. X#define        max(a, b)        (((a) > (b)) ? (a) : (b))
  278. X#define        min(a, b)        (((a) < (b)) ? (a) : (b))
  279. X
  280. Xarc_bound(arc, xmin, ymin, xmax, ymax)
  281. XF_arc    *arc;
  282. Xint    *xmin, *ymin, *xmax, *ymax;
  283. X{
  284. X    double    alpha, beta;
  285. X    double    dx, dy, radius;
  286. X    int    bx, by, sx, sy;
  287. X
  288. X    dx = arc->point[0].x - arc->center.x;
  289. X    dy = arc->center.y - arc->point[0].y;
  290. X    alpha = atan2(dy, dx);
  291. X    if (alpha < 0.0) alpha += Three_sixty_deg;
  292. X    /* compute_angle returns value between 0 to 2PI */
  293. X    
  294. X    radius = hypot(dx, dy);
  295. X
  296. X    dx = arc->point[2].x - arc->center.x;
  297. X    dy = arc->center.y - arc->point[2].y;
  298. X    beta = atan2(dy, dx);
  299. X    if (beta < 0.0) beta += Three_sixty_deg;
  300. X
  301. X    bx = max(arc->point[0].x, arc->point[1].x);
  302. X    bx = max(arc->point[2].x, bx);
  303. X    by = max(arc->point[0].y, arc->point[1].y);
  304. X    by = max(arc->point[2].y, by);
  305. X    sx = min(arc->point[0].x, arc->point[1].x);
  306. X    sx = min(arc->point[2].x, sx);
  307. X    sy = min(arc->point[0].y, arc->point[1].y);
  308. X    sy = min(arc->point[2].y, sy);
  309. X
  310. X    if (arc->direction == 1) { /* counter clockwise */
  311. X        if (alpha > beta) {
  312. X        if (alpha <= 0 || 0 <= beta)
  313. X            bx = (int)(arc->center.x + radius + 1.0);
  314. X        if (alpha <= Ninety_deg || Ninety_deg <= beta)
  315. X            sy = (int)(arc->center.y - radius - 1.0);
  316. X        if (alpha <= One_eighty_deg || One_eighty_deg <= beta)
  317. X            sx = (int)(arc->center.x - radius - 1.0);
  318. X        if (alpha <= Two_seventy_deg || Two_seventy_deg <= beta)
  319. X            by = (int)(arc->center.y + radius + 1.0);
  320. X        }
  321. X        else {
  322. X        if (0 <= beta && alpha <= 0)
  323. X            bx = (int)(arc->center.x + radius + 1.0);
  324. X        if (Ninety_deg <= beta && alpha <= Ninety_deg)
  325. X            sy = (int)(arc->center.y - radius - 1.0);
  326. X        if (One_eighty_deg <= beta && alpha <= One_eighty_deg)
  327. X            sx = (int)(arc->center.x - radius - 1.0);
  328. X        if (Two_seventy_deg <= beta && alpha <= Two_seventy_deg)
  329. X            by = (int)(arc->center.y + radius + 1.0);
  330. X        }
  331. X        }
  332. X    else {    /* clockwise    */
  333. X        if (alpha > beta) {
  334. X        if (beta <= 0 && 0 <= alpha)
  335. X            bx = (int)(arc->center.x + radius + 1.0);
  336. X        if (beta <= Ninety_deg && Ninety_deg <= alpha)
  337. X            sy = (int)(arc->center.y - radius - 1.0);
  338. X        if (beta <= One_eighty_deg && One_eighty_deg <= alpha)
  339. X            sx = (int)(arc->center.x - radius - 1.0);
  340. X        if (beta <= Two_seventy_deg && Two_seventy_deg <= alpha)
  341. X            by = (int)(arc->center.y + radius + 1.0);
  342. X        }
  343. X        else {
  344. X        if (0 <= alpha || beta <= 0)
  345. X            bx = (int)(arc->center.x + radius + 1.0);
  346. X        if (Ninety_deg <= alpha || beta <= Ninety_deg)
  347. X            sy = (int)(arc->center.y - radius - 1.0);
  348. X        if (One_eighty_deg <= alpha || beta <= One_eighty_deg)
  349. X            sx = (int)(arc->center.x - radius - 1.0);
  350. X        if (Two_seventy_deg <= alpha || beta <= Two_seventy_deg)
  351. X            by = (int)(arc->center.y + radius + 1.0);
  352. X        }
  353. X        }
  354. X    *xmax = bx; *ymax = by;
  355. X    *xmin = sx; *ymin = sy;
  356. X    }
  357. X
  358. Xcompound_bound(compound, xmin, ymin, xmax, ymax, include)
  359. XF_compound    *compound;
  360. Xint        *xmin, *ymin, *xmax, *ymax;
  361. Xint        include;
  362. X{
  363. X    F_arc        *a;
  364. X    F_ellipse    *e;
  365. X    F_compound    *c;
  366. X    F_spline    *s;
  367. X    F_line        *l;
  368. X    F_text        *t;
  369. X    int        bx, by, sx, sy, first = 1;
  370. X    int        llx, lly, urx, ury;
  371. X
  372. X    for (a = compound->arcs; a != NULL; a = a->next) {
  373. X        arc_bound(a, &sx, &sy, &bx, &by);
  374. X        if (first) {
  375. X        first = 0;
  376. X        llx = sx; lly = sy;
  377. X        urx = bx; ury = by;
  378. X        }
  379. X        else {
  380. X        llx = min(llx, sx); lly = min(lly, sy);
  381. X        urx = max(urx, bx); ury = max(ury, by);
  382. X        }
  383. X        }
  384. X
  385. X    for (c = compound->compounds; c != NULL; c = c->next) {
  386. X        compound_bound(c, &sx, &sy, &bx, &by);
  387. X        if (first) {
  388. X        first = 0;
  389. X        llx = sx; lly = sy;
  390. X        urx = bx; ury = by;
  391. X        }
  392. X        else {
  393. X        llx = min(llx, sx); lly = min(lly, sy);
  394. X        urx = max(urx, bx); ury = max(ury, by);
  395. X        }
  396. X        }
  397. X
  398. X    for (e = compound->ellipses; e != NULL; e = e->next) {
  399. X        ellipse_bound(e, &sx, &sy, &bx, &by);
  400. X        if (first) {
  401. X        first = 0;
  402. X        llx = sx; lly = sy;
  403. X        urx = bx; ury = by;
  404. X        }
  405. X        else {
  406. X        llx = min(llx, sx); lly = min(lly, sy);
  407. X        urx = max(urx, bx); ury = max(ury, by);
  408. X        }
  409. X        }
  410. X
  411. X    for (l = compound->lines; l != NULL; l = l->next) {
  412. X        line_bound(l, &sx, &sy, &bx, &by);
  413. X        if (first) {
  414. X        first = 0;
  415. X        llx = sx; lly = sy;
  416. X        urx = bx; ury = by;
  417. X        }
  418. X        else {
  419. X        llx = min(llx, sx); lly = min(lly, sy);
  420. X        urx = max(urx, bx); ury = max(ury, by);
  421. X        }
  422. X        }
  423. X
  424. X    for (s = compound->splines; s != NULL; s = s->next) {
  425. X        spline_bound(s, &sx, &sy, &bx, &by);
  426. X        if (first) {
  427. X        first = 0;
  428. X        llx = sx; lly = sy;
  429. X        urx = bx; ury = by;
  430. X        }
  431. X        else {
  432. X        llx = min(llx, sx); lly = min(lly, sy);
  433. X        urx = max(urx, bx); ury = max(ury, by);
  434. X        }
  435. X        }
  436. X
  437. X    for (t = compound->texts; t != NULL; t = t->next) {
  438. X        text_bound(t, &sx, &sy, &bx, &by, include);
  439. X        if (first) {
  440. X        first = 0;
  441. X        llx = sx; lly = sy;
  442. X        urx = bx; ury = by;
  443. X        }
  444. X        else {
  445. X        llx = min(llx, sx); lly = min(lly, sy);
  446. X        urx = max(urx, bx); ury = max(ury, by);
  447. X        }
  448. X        }
  449. X
  450. X    *xmin = llx; *ymin = lly;
  451. X    *xmax = urx; *ymax = ury;
  452. X    }
  453. X
  454. Xellipse_bound(e, xmin, ymin, xmax, ymax)
  455. XF_ellipse    *e;
  456. Xint        *xmin, *ymin, *xmax, *ymax;
  457. X{
  458. X    *xmin = e->center.x - e->radiuses.x;
  459. X    *ymin = e->center.y - e->radiuses.y;
  460. X    *xmax = e->center.x + e->radiuses.x;
  461. X    *ymax = e->center.y + e->radiuses.y;
  462. X    }
  463. X
  464. Xline_bound(l, xmin, ymin, xmax, ymax)
  465. XF_line    *l;
  466. Xint    *xmin, *ymin, *xmax, *ymax;
  467. X{
  468. X    points_bound(l->points, xmin, ymin, xmax, ymax);
  469. X    }
  470. X
  471. Xspline_bound(s, xmin, ymin, xmax, ymax)
  472. XF_spline    *s;
  473. Xint        *xmin, *ymin, *xmax, *ymax;
  474. X{
  475. X    if (int_spline(s)) {
  476. X        int_spline_bound(s, xmin, ymin, xmax, ymax);
  477. X        }
  478. X    else {
  479. X        normal_spline_bound(s, xmin, ymin, xmax, ymax);
  480. X        }
  481. X    }
  482. X
  483. Xint_spline_bound(s, xmin, ymin, xmax, ymax)
  484. XF_spline    *s;
  485. Xint        *xmin, *ymin, *xmax, *ymax;
  486. X{
  487. X    F_point        *p1, *p2;
  488. X    F_control    *cp1, *cp2;
  489. X    double        x0, y0, x1, y1, x2, y2, x3, y3, sx1, sy1, sx2, sy2;
  490. X    double        tx, ty, tx1, ty1, tx2, ty2;
  491. X    double        sx, sy, bx, by;
  492. X
  493. X    p1 = s->points;
  494. X    sx = bx = p1->x;
  495. X    sy = by = p1->y;
  496. X    cp1 = s->controls;
  497. X    for (p2 = p1->next, cp2 = cp1->next; p2 != NULL;
  498. X        p1 = p2, cp1 = cp2, p2 = p2->next, cp2 = cp2->next) {
  499. X        x0 = p1->x; y0 = p1->y;
  500. X        x1 = cp1->rx; y1 = cp1->ry;
  501. X        x2 = cp2->lx; y2 = cp2->ly;
  502. X        x3 = p2->x; y3 = p2->y;
  503. X        tx = half(x1, x2); ty = half(y1, y2);
  504. X        sx1 = half(x0, x1); sy1 = half(y0, y1);
  505. X        sx2 = half(sx1, tx); sy2 = half(sy1, ty);
  506. X        tx2 = half(x2, x3); ty2 = half(y2, y3);
  507. X        tx1 = half(tx2, tx); ty1 = half(ty2, ty);
  508. X
  509. X        sx = min(x0, sx); sy = min(y0, sy);
  510. X        sx = min(sx1, sx); sy = min(sy1, sy);
  511. X        sx = min(sx2, sx); sy = min(sy2, sy);
  512. X        sx = min(tx1, sx); sy = min(ty1, sy);
  513. X        sx = min(tx2, sx); sy = min(ty2, sy);
  514. X        sx = min(x3, sx); sy = min(y3, sy);
  515. X
  516. X        bx = max(x0, bx); by = max(y0, by);
  517. X        bx = max(sx1, bx); by = max(sy1, by);
  518. X        bx = max(sx2, bx); by = max(sy2, by);
  519. X        bx = max(tx1, bx); by = max(ty1, by);
  520. X        bx = max(tx2, bx); by = max(ty2, by);
  521. X        bx = max(x3, bx); by = max(y3, by);
  522. X        }
  523. X    *xmin = round(sx);
  524. X    *ymin = round(sy);
  525. X    *xmax = round(bx);
  526. X    *ymax = round(by);
  527. X    }
  528. X
  529. Xnormal_spline_bound(s, xmin, ymin, xmax, ymax)
  530. XF_spline    *s;
  531. Xint        *xmin, *ymin, *xmax, *ymax;
  532. X{
  533. X    F_point    *p;
  534. X    double    cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
  535. X    double    x1, y1, x2, y2, sx, sy, bx, by;
  536. X    double    px, py, qx, qy;
  537. X
  538. X    p = s->points;
  539. X    x1 = p->x;  y1 = p->y;
  540. X    p = p->next;
  541. X    x2 = p->x;  y2 = p->y;
  542. X    cx1 = (x1 + x2) / 2.0;   cy1 = (y1 + y2) / 2.0;
  543. X    cx2 = (cx1 + x2) / 2.0;  cy2 = (cy1 + y2) / 2.0;
  544. X    if (closed_spline(s)) {
  545. X        x1 = (cx1 + x1) / 2.0;
  546. X        y1 = (cy1 + y1) / 2.0;
  547. X        }
  548. X    sx = min(x1, cx2); sy = min(y1, cy2);
  549. X    bx = max(x1, cx2); by = max(y1, cy2);
  550. X
  551. X    for (p = p->next; p != NULL; p = p->next) {
  552. X        x1 = x2;  y1 = y2;
  553. X        x2 = p->x;  y2 = p->y;
  554. X        cx4 = (x1 + x2) / 2.0; cy4 = (y1 + y2) / 2.0;
  555. X        cx3 = (x1 + cx4) / 2.0; cy3 = (y1 + cy4) / 2.0;
  556. X        cx2 = (cx4 + x2) / 2.0;  cy2 = (cy4 + y2) / 2.0;
  557. X
  558. X        px = min(cx2, cx3); py = min(cy2, cy3);
  559. X        qx = max(cx2, cx3); qy = max(cy2, cy3);
  560. X
  561. X        sx = min(sx, px); sy = min(sy, py);
  562. X        bx = max(bx, qx); by = max(by, qy);
  563. X        }
  564. X    if (closed_spline(s)) {
  565. X        *xmin = round(sx); *ymin = round(sy);
  566. X        *xmax = round(bx); *ymax = round(by);
  567. X        }
  568. X    else {
  569. X        *xmin = round(min(sx, x2)); *ymin = round(min(sy, y2));
  570. X        *xmax = round(max(bx, x2)); *ymax = round(max(by, y2));
  571. X        }
  572. X    }
  573. X
  574. Xtext_bound(t, xmin, ymin, xmax, ymax, include)
  575. XF_text    *t;
  576. Xint    *xmin, *ymin, *xmax, *ymax;
  577. Xint    include;
  578. X{
  579. X    if (t->type == T_CENTER_JUSTIFIED) {
  580. X        *xmin = t->base_x - t->length / 2;
  581. X        *xmax = t->base_x + t->length / 2;
  582. X    } else if (t->type == T_RIGHT_JUSTIFIED) {
  583. X        *xmin = t->base_x - t->length;
  584. X        *xmax = t->base_x;
  585. X    } else {
  586. X        *xmin = t->base_x;
  587. X        *xmax = t->base_x + (include ? t->length : 0);
  588. X    }
  589. X    *ymax = t->base_y;
  590. X    *ymin = t->base_y - t->height;
  591. X    }
  592. X
  593. Xpoints_bound(points, xmin, ymin, xmax, ymax)
  594. XF_point    *points;
  595. Xint    *xmin, *ymin, *xmax, *ymax;
  596. X{
  597. X    int    bx, by, sx, sy;
  598. X    F_point    *p;
  599. X
  600. X    bx = sx = points->x; by = sy = points->y;
  601. X    for (p = points->next; p != NULL; p = p->next) {
  602. X        sx = min(sx, p->x); sy = min(sy, p->y);
  603. X        bx = max(bx, p->x); by = max(by, p->y);
  604. X        }
  605. X    *xmin = sx; *ymin = sy;
  606. X    *xmax = bx; *ymax = by;
  607. X    }
  608. X
  609. Xcontrol_points_bound(cps, xmin, ymin, xmax, ymax)
  610. XF_control    *cps;
  611. Xint        *xmin, *ymin, *xmax, *ymax;
  612. X{
  613. X    F_control    *c;
  614. X    double        bx, by, sx, sy;
  615. X
  616. X    bx = sx = cps->lx;
  617. X    by = sy = cps->ly;
  618. X    sx = min(sx, cps->rx); sy = min(sy, cps->ry);
  619. X    bx = max(bx, cps->rx); by = max(by, cps->ry);
  620. X    for (c = cps->next; c != NULL; c = c->next) {
  621. X        sx = min(sx, c->lx); sy = min(sy, c->ly);
  622. X        bx = max(bx, c->lx); by = max(by, c->ly);
  623. X        sx = min(sx, c->rx); sy = min(sy, c->ry);
  624. X        bx = max(bx, c->rx); by = max(by, c->ry);
  625. X        }
  626. X    *xmin = round(sx); *ymin = round(sy);
  627. X    *xmax = round(bx); *ymax = round(by);
  628. X    }
  629. END_OF_FILE
  630. if test 9753 -ne `wc -c <'transfig/fig2dev/bound.c'`; then
  631.     echo shar: \"'transfig/fig2dev/bound.c'\" unpacked with wrong size!
  632. fi
  633. # end of 'transfig/fig2dev/bound.c'
  634. fi
  635. if test -f 'transfig/fig2dev/fig2dev.c' -a "${1}" != "-c" ; then 
  636.   echo shar: Will not clobber existing file \"'transfig/fig2dev/fig2dev.c'\"
  637. else
  638. echo shar: Extracting \"'transfig/fig2dev/fig2dev.c'\" \(5666 characters\)
  639. sed "s/^X//" >'transfig/fig2dev/fig2dev.c' <<'END_OF_FILE'
  640. X/* 
  641. X *    Fig2dev : General Fig code translation program
  642. X *
  643. X*/
  644. X#ifdef hpux
  645. X#include <sys/types.h>
  646. X#endif
  647. X#include <sys/file.h>
  648. X#include <stdio.h>
  649. X#include <ctype.h>
  650. X#include "object.h"
  651. X#include "fig2dev.h"
  652. X#include "drivers.h"
  653. X
  654. Xextern int getopt();
  655. Xextern char *optarg;
  656. Xextern int optind;
  657. X
  658. X#define DEFAULT_FONT_SIZE 11
  659. X
  660. Xstruct driver *dev = NULL;
  661. X
  662. Xchar        Usage[] = "Usage: %s [-L language] [-f font] [-s size] [-m scale] [input [output]]\n";
  663. Xchar        Err_badarg[] = "Argument -%c unkown to %s driver.";
  664. Xchar        Err_incomp[] = "Incomplete %s object at line %d.";
  665. Xchar        Err_mem[] = "Running out of memory.";
  666. X
  667. Xchar        *prog;
  668. Xchar        *from = NULL, *to = NULL;
  669. Xint        font_size = 0;
  670. Xdouble        mag = 1.0;
  671. XFILE        *tfp = NULL;
  672. Xint        llx = 0, lly = 0, urx = 0, ury = 0;
  673. X
  674. Xstruct obj_rec {
  675. X    void (*gendev)();
  676. X    char *obj;
  677. X    int depth;
  678. X};
  679. X
  680. Xput_msg(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
  681. Xchar   *format, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7, *arg8;
  682. X{
  683. X    fprintf(stderr, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  684. X    fprintf(stderr, "\n");
  685. X    }
  686. X
  687. Xget_args(argc, argv)
  688. Xint     argc;
  689. Xchar    *argv[];
  690. X{
  691. X      int    c, i;
  692. X    double    atof();
  693. X
  694. X    prog = *argv;
  695. X/* add :? */
  696. X    while ((c = getopt(argc, argv, "cd:f:l:L:m:Pp:s:S:vwW:?")) != EOF) {
  697. X
  698. X      /* generic option handling */
  699. X      switch (c) {
  700. X
  701. X        case 'L':            /* set output language */
  702. X            for (i=0; *drivers[i].name; i++) 
  703. X            if (!strcmp(optarg, drivers[i].name))
  704. X                dev = drivers[i].dev;
  705. X            if (!dev) {
  706. X            fprintf(stderr,
  707. X                "Unknown graphics language %s\n", optarg);
  708. X            fprintf(stderr,"Known languages are:\n");
  709. X            /* display available languages - 23/01/90 */
  710. X            for (i=0; *drivers[i].name; i++)
  711. X                fprintf(stderr,"%s ",drivers[i].name);
  712. X            fprintf(stderr,"\n");
  713. X            exit(1);
  714. X            }
  715. X            break;
  716. X
  717. X        case 's':            /* set default font size */
  718. X            font_size = atoi(optarg);
  719. X            break;
  720. X
  721. X        case 'm':            /* set magnification */
  722. X            mag = atof(optarg);
  723. X            break;
  724. X
  725. X        case '?':            /* usage         */
  726. X            fprintf(stderr,Usage,prog);
  727. X            exit(1);
  728. X        }
  729. X
  730. X        /* pass options through to driver */
  731. X        if (!dev) {
  732. X        fprintf(stderr, "No graphics language specified.\n");
  733. X        exit(1);
  734. X        }
  735. X        dev->option(c, optarg);
  736. X      }
  737. X
  738. X    /* default font size is scaled if not specified */
  739. X    if (!font_size) font_size = DEFAULT_FONT_SIZE*mag + 0.5;
  740. X
  741. X    if (optind < argc) from = argv[optind++];  /*  from file  */
  742. X    if (optind < argc) to   = argv[optind];  /*  to file    */
  743. X}
  744. X
  745. Xmain(argc, argv)
  746. Xint     argc;
  747. Xchar    *argv[];
  748. X{
  749. X    F_compound    objects;
  750. X    int        status;
  751. X
  752. X    get_args(argc, argv);
  753. X
  754. X    if (to == NULL)
  755. X        tfp = stdout;
  756. X    else if ((tfp = fopen(to, "w")) == NULL) {
  757. X        fprintf(stderr, "Couldn't open %s", to);
  758. X        fprintf(stderr, Usage, prog);
  759. X        exit(1);
  760. X        }
  761. X
  762. X    if (from)
  763. X        status = read_fig(from, &objects);
  764. X    else    /* read from stdin */
  765. X        status = readfp_fig(stdin, &objects);
  766. X
  767. X    if (status != 0) {
  768. X        if (from) read_fail_message(from, status);
  769. X        exit(1);
  770. X        }
  771. X    gendev_objects(&objects, dev);
  772. X    if (tfp != stdout) (void)fclose(tfp);
  773. X    exit(0);
  774. X    }
  775. X
  776. X/* count primitive objects & create pointer array */
  777. Xstatic int compound_dump(com, array, count, dev)
  778. XF_compound *com;
  779. Xstruct obj_rec *array;
  780. Xint count;
  781. Xstruct driver *dev;
  782. X{
  783. X      F_arc        *a;
  784. X    F_compound    *c;
  785. X    F_ellipse    *e;
  786. X    F_line        *l;
  787. X    F_spline    *s;
  788. X    F_text        *t;
  789. X
  790. X    for (c = com->compounds; c != NULL; c = c->next)
  791. X      count = compound_dump(c, array, count, dev);
  792. X    for (a = com->arcs; a != NULL; a = a->next) {
  793. X      if (array) {
  794. X        array[count].gendev = dev->arc;
  795. X        array[count].obj = (char *)a;
  796. X        array[count].depth = a->depth;
  797. X      }
  798. X      count += 1;
  799. X    }
  800. X    for (e = com->ellipses; e != NULL; e = e->next) {
  801. X      if (array) {
  802. X        array[count].gendev = dev->ellipse;
  803. X        array[count].obj = (char *)e;
  804. X        array[count].depth = e->depth;
  805. X      }
  806. X      count += 1;
  807. X    }
  808. X    for (l = com->lines; l != NULL; l = l->next) {
  809. X      if (array) {
  810. X        array[count].gendev = dev->line;
  811. X        array[count].obj = (char *)l;
  812. X        array[count].depth = l->depth;
  813. X      }
  814. X      count += 1;
  815. X    }
  816. X    for (s = com->splines; s != NULL; s = s->next) {
  817. X      if (array) {
  818. X        array[count].gendev = dev->spline;
  819. X        array[count].obj = (char *)s;
  820. X        array[count].depth = s->depth;
  821. X      }
  822. X      count += 1;
  823. X    }
  824. X    for (t = com->texts; t != NULL; t = t->next) {
  825. X      if (array) {
  826. X        array[count].gendev = dev->text;
  827. X        array[count].obj = (char *)t;
  828. X        array[count].depth = t->depth;
  829. X      }
  830. X      count += 1;
  831. X    }
  832. X    return count;
  833. X}
  834. X
  835. Xgendev_objects(objects, dev)
  836. XF_compound    *objects;
  837. Xstruct driver *dev;
  838. X{
  839. X    F_arc        *a;
  840. X    F_compound    *c;
  841. X    F_ellipse    *e;
  842. X    F_line        *l;
  843. X    F_spline    *s;
  844. X    F_text        *t;
  845. X
  846. X    int obj_count, rec_comp();
  847. X    struct obj_rec *rec_array, *r; 
  848. X
  849. X    if (0 == (double)objects->nwcorner.x) {
  850. X        fprintf(stderr, "Resolution is zero!! default to 80 ppi\n");
  851. X        objects->nwcorner.x = 80;
  852. X        }
  853. X    if (objects->nwcorner.y != 1 && objects->nwcorner.y != 2) {
  854. X        fprintf(stderr, "Wrong coordinate system; cannot continue\n");
  855. X        return;
  856. X        }
  857. X
  858. X    /* Compute bounding box of objects, supressing texts if indicated */
  859. X    compound_bound(objects, &llx, &lly, &urx, &ury, dev->text_include);
  860. X
  861. X    /* dump object pointers to an array */
  862. X    obj_count = compound_dump(objects, 0, 0, dev);
  863. X    if (!obj_count) {
  864. X        fprintf(stderr, "No object");
  865. X        return;
  866. X        }
  867. X    rec_array = (struct obj_rec *)malloc(obj_count*sizeof(struct obj_rec));
  868. X    (void)compound_dump(objects, rec_array, 0, dev);
  869. X
  870. X    /* sort object array by depth */
  871. X    qsort(rec_array, obj_count, sizeof(struct obj_rec), rec_comp);
  872. X
  873. X    /* generate header */
  874. X    (*dev->start)(objects);
  875. X
  876. X    /* generate objects in sorted order */
  877. X    for (r = rec_array; r<rec_array+obj_count; r++)
  878. X        (*(r->gendev))(r->obj);
  879. X
  880. X    /* generate trailer */
  881. X    (*dev->end)();
  882. X}
  883. X
  884. Xint rec_comp(r1, r2)
  885. Xstruct obj_rec *r1, *r2;
  886. X{
  887. X    return (r2->depth - r1->depth);
  888. X}
  889. X
  890. X/* null operation */
  891. Xvoid gendev_null() {};
  892. END_OF_FILE
  893. if test 5666 -ne `wc -c <'transfig/fig2dev/fig2dev.c'`; then
  894.     echo shar: \"'transfig/fig2dev/fig2dev.c'\" unpacked with wrong size!
  895. fi
  896. # end of 'transfig/fig2dev/fig2dev.c'
  897. fi
  898. if test -f 'transfig/fig2dev/latex_line.c' -a "${1}" != "-c" ; then 
  899.   echo shar: Will not clobber existing file \"'transfig/fig2dev/latex_line.c'\"
  900. else
  901. echo shar: Extracting \"'transfig/fig2dev/latex_line.c'\" \(4499 characters\)
  902. sed "s/^X//" >'transfig/fig2dev/latex_line.c' <<'END_OF_FILE'
  903. X#include <stdio.h>
  904. X#include <math.h>
  905. X/* 
  906. X *    latex_line.c: 
  907. X *        Subroutines for drawing and translating lines for the LaTeX
  908. X *        picture environment.
  909. X *    Written by Frank Schmuck (schmuck@svax.cs.cornell.edu)
  910. X *    June 1988
  911. X *
  912. X *    The LaTeX picture environment allows generating pictures in standard
  913. X *    LaTeX.  However, some restrictions apply:  lines and vectors (a vector
  914. X *    is a line with an arrow at the end) can only be drawn with a finite
  915. X *    number of slopes.  The available slopes are given by dy/dx where
  916. X *    dx and dy must be integers <= 6 for lines and <= 4 for vectors.
  917. X *
  918. X *    The subroutines in this file are used in fig2latex to approximate
  919. X *    an arbitrary line or vector by a LaTeX line/vector, and in fig to 
  920. X *    restrict line drawing to slopes supported by LaTeX.
  921. X */
  922. X
  923. X/*
  924. X * Constant for converting from radian to degrees
  925. X */
  926. Xdouble rad2deg = 57.295779513082320877;
  927. X
  928. Xint  pgcd(a,b)
  929. X    int a, b;
  930. X/*
  931. X *  compute greatest common divisor, assuming 0 < a <= b
  932. X */
  933. X{
  934. X    b = b % a;
  935. X    return (b)? gcd(b, a): a;
  936. X}
  937. X
  938. Xint  gcd(a, b)
  939. X    int a, b;
  940. X/*
  941. X *  compute greatest common divisor
  942. X */
  943. X{
  944. X    if (a < 0) a = -a;
  945. X    if (b < 0) b = -b;
  946. X    return (a <= b)? pgcd(a, b): pgcd(b, a);
  947. X}
  948. X
  949. Xint  lcm(a, b)
  950. X    int a, b;
  951. X/*
  952. X *  Compute least common multiple
  953. X */
  954. X{
  955. X    return abs(a*b)/gcd(a,b);
  956. X}
  957. X
  958. X/*
  959. X *  Tables of line and vector slopes supported by LaTeX
  960. X */
  961. X 
  962. Xstruct angle_table {
  963. X    int    x, y;
  964. X    double angle;
  965. X};
  966. X
  967. X#define N_LINE 25
  968. X
  969. Xstruct angle_table line_angles[N_LINE] =
  970. X  { {0, 1, 90.0}, 
  971. X    {1, 0,  0.0},
  972. X    {1, 1, 45.0}, 
  973. X    {1, 2, 63.434948822922010648},
  974. X    {1, 3, 71.565051177077989351},
  975. X    {1, 4, 75.963756532073521417},
  976. X    {1, 5, 78.690067525979786913},
  977. X    {1, 6, 80.537677791974382609},
  978. X    {2, 1, 26.565051177077989351},
  979. X    {2, 3, 56.309932474020213086},
  980. X    {2, 5, 68.198590513648188229}, 
  981. X    {3, 1, 18.434948822922010648},
  982. X    {3, 2, 33.690067525979786913},
  983. X    {3, 4, 53.130102354155978703},
  984. X    {3, 5, 59.036243467926478582},
  985. X    {4, 1, 14.036243467926478588},
  986. X    {4, 3, 36.869897645844021297},
  987. X    {4, 5, 51.340191745909909396},
  988. X    {5, 1, 11.309932474020213086},
  989. X    {5, 2, 21.801409486351811770},
  990. X    {5, 3, 30.963756532073521417},
  991. X    {5, 4, 38.659808254090090604},
  992. X    {5, 6, 50.194428907734805993},
  993. X    {6, 1, 9.4623222080256173906},
  994. X    {6, 5, 39.805571092265194006}
  995. X  };
  996. X
  997. X#define N_ARROW 13
  998. X
  999. Xstruct angle_table arrow_angles[N_ARROW] =
  1000. X  { {0, 1, 90.0}, 
  1001. X    {1, 0,  0.0},
  1002. X    {1, 1, 45.0}, 
  1003. X    {1, 2, 63.434948822922010648},
  1004. X    {1, 3, 71.565051177077989351},
  1005. X    {1, 4, 75.963756532073521417},
  1006. X    {2, 1, 26.565051177077989351},
  1007. X    {2, 3, 56.309932474020213086},
  1008. X    {3, 1, 18.434948822922010648},
  1009. X    {3, 2, 33.690067525979786913},
  1010. X    {3, 4, 53.130102354155978703},
  1011. X    {4, 1, 14.036243467926478588},
  1012. X    {4, 3, 36.869897645844021297},
  1013. X  };
  1014. X
  1015. Xget_slope(dx, dy, sxp, syp, arrow)
  1016. X    int  dx, dy, *sxp, *syp, arrow;
  1017. X/*
  1018. X *  Find the LaTeX line slope that is closest to the one given by dx, dy.
  1019. X *  Result is returned in *sxp, *syp.  If (arrow != 0) the closest LaTeX
  1020. X *  vector slope is selected.
  1021. X */
  1022. X{
  1023. X    double angle;
  1024. X    int    i, s, max;
  1025. X    double d, d1;
  1026. X    struct angle_table *st;
  1027. X
  1028. X    if (dx == 0) {
  1029. X    *sxp = 0;
  1030. X    *syp = (dy < 0)? -1: 1;
  1031. X    return;
  1032. X    }
  1033. X    angle = atan((double)abs(dy) / (double)abs(dx)) * rad2deg;
  1034. X    if (arrow) {
  1035. X    st = arrow_angles;
  1036. X    max = N_ARROW;
  1037. X    } else {
  1038. X    st = line_angles;
  1039. X    max = N_LINE;
  1040. X    }
  1041. X    s = 0;
  1042. X    d = 9.9e9;
  1043. X    for (i = 0; i < max; i++) {
  1044. X    d1 = fabs(angle - st[i].angle);
  1045. X    if (d1 < d) {
  1046. X        s = i;
  1047. X        d = d1;
  1048. X    } 
  1049. X    }
  1050. X    *sxp = st[s].x;
  1051. X    if (dx < 0) *sxp = -*sxp;
  1052. X    *syp = st[s].y;
  1053. X    if (dy < 0) *syp = -*syp;
  1054. X}
  1055. X
  1056. Xlatex_endpoint(x1, y1, x2, y2, xout, yout, arrow, magnet)
  1057. X    int  x1, y1, x2, y2;
  1058. X    int  *xout, *yout;
  1059. X    int  arrow, magnet;
  1060. X/*
  1061. X *  Computes a point "close" to (x2,y2) that is reachable from (x1,y1)
  1062. X *  by a LaTeX line (LaTeX vector if arrow != 0).  The result is returned
  1063. X *  in *xout, *yout.  If (magnet > 1) the point returned is selected such that
  1064. X *  (*xout - x1) and (*yout - y1) are both multiples of magnet.
  1065. X */
  1066. X{
  1067. X    int    dx, dy, sx, sy, ds, dsx, dsy;
  1068. X
  1069. X    dx = x2-x1;
  1070. X    dy = y2-y1;
  1071. X    get_slope(dx, dy, &sx, &sy, arrow);
  1072. X    if (abs(sx) >= abs(sy)) {
  1073. X    ds = lcm(sx, magnet*gcd(sx,magnet));
  1074. X    dsx = (2*abs(dx)/ds + 1)/2;
  1075. X    dsx = (dx >= 0)? dsx*ds: -dsx*ds;
  1076. X    *xout = x1 + dsx;
  1077. X    *yout = y1 + dsx*sy/sx;
  1078. X    } else {
  1079. X    ds = lcm(sy, magnet*gcd(sy,magnet));
  1080. X    dsy = (2*abs(dy)/ds + 1)/2;
  1081. X    dsy = (dy >= 0)? dsy*ds: -dsy*ds;
  1082. X    *yout = y1 + dsy;
  1083. X    *xout = x1 + dsy*sx/sy;
  1084. X    }
  1085. X}
  1086. END_OF_FILE
  1087. if test 4499 -ne `wc -c <'transfig/fig2dev/latex_line.c'`; then
  1088.     echo shar: \"'transfig/fig2dev/latex_line.c'\" unpacked with wrong size!
  1089. fi
  1090. # end of 'transfig/fig2dev/latex_line.c'
  1091. fi
  1092. if test -f 'transfig/fig2dev/object.h' -a "${1}" != "-c" ; then 
  1093.   echo shar: Will not clobber existing file \"'transfig/fig2dev/object.h'\"
  1094. else
  1095. echo shar: Extracting \"'transfig/fig2dev/object.h'\" \(4954 characters\)
  1096. sed "s/^X//" >'transfig/fig2dev/object.h' <<'END_OF_FILE'
  1097. X#define                    DEFAULT            (-1)
  1098. X
  1099. Xtypedef        struct f_pattern {
  1100. X            int            w, h;
  1101. X            int            *p;
  1102. X            }
  1103. X        F_pattern;
  1104. X
  1105. Xtypedef        struct f_pen {
  1106. X            int            x, y;
  1107. X            int            *p;
  1108. X            }
  1109. X        F_pen;
  1110. X
  1111. Xtypedef        struct f_point {
  1112. X            int            x, y;
  1113. X            struct f_point        *next;
  1114. X            }
  1115. X        F_point;
  1116. X
  1117. Xtypedef        struct f_pos {
  1118. X            int            x, y;
  1119. X            }
  1120. X        F_pos;
  1121. X
  1122. Xtypedef        struct f_arrow {
  1123. X            int            type;
  1124. X            int            style;
  1125. X            double            thickness;
  1126. X            double            wid;
  1127. X            double            ht;
  1128. X            }
  1129. X        F_arrow;
  1130. X
  1131. Xtypedef        struct f_ellipse {
  1132. X            int            type;
  1133. X#define                    T_ELLIPSE_BY_RAD    1
  1134. X#define                    T_ELLIPSE_BY_DIA    2
  1135. X#define                    T_CIRCLE_BY_RAD        3
  1136. X#define                    T_CIRCLE_BY_DIA        4
  1137. X            int            style;
  1138. X            int            thickness;
  1139. X            int            color;
  1140. X#define                    BLACK            0
  1141. X            int            depth;
  1142. X            int            direction;
  1143. X            double            style_val;
  1144. X            double            angle;
  1145. X            struct f_pen        *pen;
  1146. X            struct f_pattern    *area_fill;
  1147. X#define                           UNFILLED    (F_pattern *)0
  1148. X#define                           BLACK_FILL    (F_pattern *)1
  1149. X#define                           DARK_GRAY_FILL    (F_pattern *)2
  1150. X#define                           MED_GRAY_FILL    (F_pattern *)3
  1151. X#define                           LIGHT_GRAY_FILL    (F_pattern *)4
  1152. X#define                           WHITE_FILL    (F_pattern *)5
  1153. X            struct f_pos        center;
  1154. X            struct f_pos        radiuses;
  1155. X            struct f_pos        start;
  1156. X            struct f_pos        end;
  1157. X            struct f_ellipse    *next;
  1158. X            }
  1159. X        F_ellipse;
  1160. X
  1161. Xtypedef        struct f_arc {
  1162. X            int            type;
  1163. X#define                    T_3_POINTS_ARC        1
  1164. X            int            style;
  1165. X            int            thickness;
  1166. X            int            color;
  1167. X            int            depth;
  1168. X            struct f_pen        *pen;
  1169. X            struct f_pattern    *area_fill;
  1170. X            double            style_val;
  1171. X            int            direction;
  1172. X            struct f_arrow        *for_arrow;
  1173. X            struct f_arrow        *back_arrow;
  1174. X            struct {double x, y;}    center;
  1175. X            struct f_pos        point[3];
  1176. X            struct f_arc        *next;
  1177. X            }
  1178. X        F_arc;
  1179. X
  1180. Xtypedef        struct f_line {
  1181. X            int            type;
  1182. X#define                    T_POLYLINE    1
  1183. X#define                    T_BOX        2
  1184. X#define                    T_POLYGON    3
  1185. X#define                                    T_ARC_BOX       4
  1186. X/* JNT */
  1187. X            int            style;
  1188. X            int            thickness;
  1189. X            int            color;
  1190. X            int            depth;
  1191. X            double            style_val;
  1192. X            int            radius;    /* for T_ARC_BOX */
  1193. X            struct f_pen        *pen;
  1194. X            struct f_pattern    *area_fill;
  1195. X            struct f_arrow        *for_arrow;
  1196. X            struct f_arrow        *back_arrow;
  1197. X            struct f_point        *points;
  1198. X            struct f_line        *next;
  1199. X            }
  1200. X        F_line;
  1201. X
  1202. Xtypedef        struct f_text {
  1203. X            int            type;
  1204. X#define                    T_LEFT_JUSTIFIED    0
  1205. X#define                    T_CENTER_JUSTIFIED    1
  1206. X#define                    T_RIGHT_JUSTIFIED    2
  1207. X            int            font;
  1208. X#define                    DEFAULT_FONT        0
  1209. X#define                    ROMAN_FONT        1
  1210. X#define                    BOLD_FONT        2
  1211. X#define                    ITALIC_FONT        3
  1212. X#define                    MODERN_FONT        4
  1213. X#define                    TYPEWRITER_FONT        5
  1214. X            int            size;    /* point size */
  1215. X            int            color;
  1216. X            int            depth;
  1217. X            double            angle;    /* in radian */
  1218. X            int            style;
  1219. X#define                    PLAIN        1
  1220. X#define                    ITALIC        2
  1221. X#define                    BOLD        4
  1222. X#define                    OUTLINE        8
  1223. X#define                    SHADOW        16
  1224. X            int            height;    /* pixels */
  1225. X            int            length;    /* pixels */
  1226. X            int            base_x;
  1227. X            int            base_y;
  1228. X            struct f_pen        *pen;
  1229. X            char            *cstring;
  1230. X            struct f_text        *next;
  1231. X            }
  1232. X        F_text;
  1233. X
  1234. Xtypedef        struct f_control {
  1235. X            double            lx, ly, rx, ry;
  1236. X            struct f_control    *next;
  1237. X            }
  1238. X        F_control;
  1239. X
  1240. X#define        int_spline(s)        (s->type & 0x2)
  1241. X#define        normal_spline(s)    (!(s->type & 0x2))
  1242. X#define        closed_spline(s)    (s->type & 0x1)
  1243. X#define        open_spline(s)        (!(s->type & 0x1))
  1244. X
  1245. Xtypedef        struct f_spline {
  1246. X            int            type;
  1247. X#define                    T_OPEN_NORMAL        0
  1248. X#define                    T_CLOSED_NORMAL        1
  1249. X#define                    T_OPEN_INTERPOLATED    2
  1250. X#define                    T_CLOSED_INTERPOLATED    3
  1251. X            int            style;
  1252. X            int            thickness;
  1253. X            int            color;
  1254. X            int            depth;
  1255. X            double            style_val;
  1256. X            struct f_pen        *pen;
  1257. X            struct f_pattern    *area_fill;
  1258. X            struct f_arrow        *for_arrow;
  1259. X            struct f_arrow        *back_arrow;
  1260. X            /*
  1261. X            For T_OPEN_NORMAL and T_CLOSED_NORMAL points
  1262. X            are control points while they are knots for
  1263. X            T_OPEN_INTERPOLATED and T_CLOSED_INTERPOLTED
  1264. X            whose control points are stored in controls.
  1265. X            */
  1266. X            struct f_point        *points;
  1267. X            struct f_control    *controls;
  1268. X            struct f_spline        *next;
  1269. X            }
  1270. X        F_spline;
  1271. X
  1272. Xtypedef        struct f_compound {
  1273. X            struct f_pos        nwcorner;
  1274. X            struct f_pos        secorner;
  1275. X            struct f_line        *lines;
  1276. X            struct f_ellipse    *ellipses;
  1277. X            struct f_spline        *splines;
  1278. X            struct f_text        *texts;
  1279. X            struct f_arc        *arcs;
  1280. X            struct f_compound    *compounds;
  1281. X            struct f_compound    *next;
  1282. X            }
  1283. X        F_compound;
  1284. X
  1285. X#define        ARROW_SIZE        sizeof(struct f_arrow)
  1286. X#define        POINT_SIZE        sizeof(struct f_point)
  1287. X#define        CONTROL_SIZE        sizeof(struct f_control)
  1288. X#define        ELLOBJ_SIZE        sizeof(struct f_ellipse)
  1289. X#define        ARCOBJ_SIZE        sizeof(struct f_arc)
  1290. X#define        LINOBJ_SIZE        sizeof(struct f_line)
  1291. X#define        TEXOBJ_SIZE        sizeof(struct f_text)
  1292. X#define        SPLOBJ_SIZE        sizeof(struct f_spline)
  1293. X#define        COMOBJ_SIZE        sizeof(struct f_compound)
  1294. X
  1295. X/**********************  object codes  **********************/
  1296. X
  1297. X#define        O_ELLIPSE        1
  1298. X#define        O_POLYLINE        2
  1299. X#define        O_SPLINE        3
  1300. X#define        O_TEXT            4
  1301. X#define        O_ARC            5
  1302. X#define        O_COMPOUND        6
  1303. X#define        O_END_COMPOUND        (-O_COMPOUND)
  1304. X#define        O_ALL_OBJECT        99
  1305. X
  1306. X/************  object styles (except for f_text)  ************/
  1307. X
  1308. X#define        SOLID_LINE        0
  1309. X#define        DASH_LINE        1
  1310. X#define        DOTTED_LINE        2
  1311. X
  1312. X#define        CLOSED_PATH        0
  1313. X#define        OPEN_PATH        1
  1314. END_OF_FILE
  1315. if test 4954 -ne `wc -c <'transfig/fig2dev/object.h'`; then
  1316.     echo shar: \"'transfig/fig2dev/object.h'\" unpacked with wrong size!
  1317. fi
  1318. # end of 'transfig/fig2dev/object.h'
  1319. fi
  1320. if test -f 'transfig/fig2dev/read1_3.c' -a "${1}" != "-c" ; then 
  1321.   echo shar: Will not clobber existing file \"'transfig/fig2dev/read1_3.c'\"
  1322. else
  1323. echo shar: Extracting \"'transfig/fig2dev/read1_3.c'\" \(9833 characters\)
  1324. sed "s/^X//" >'transfig/fig2dev/read1_3.c' <<'END_OF_FILE'
  1325. X/*******************************************************************/
  1326. X/***************       Read version 1.3 format       ***************/
  1327. X/*******************************************************************/
  1328. X#include <stdio.h>
  1329. X#include <sys/types.h>
  1330. X#include <sys/stat.h>
  1331. X#include <errno.h>
  1332. X#include "alloc.h"
  1333. X#include "object.h"
  1334. X
  1335. X/*******    Fig 1.3 subtype of objects    *******/
  1336. X#define            DRAW_ELLIPSE_BY_RAD     1
  1337. X#define            DRAW_ELLIPSE_BY_DIA     2
  1338. X#define            DRAW_CIRCLE_BY_RAD     3
  1339. X#define            DRAW_CIRCLE_BY_DIA     4
  1340. X#define            DRAW_CIRCULAR_ARC    5
  1341. X#define            DRAW_POLYLINE        6
  1342. X#define            DRAW_BOX        7
  1343. X#define            DRAW_POLYGON        8
  1344. X#define            DRAW_TEXT        9
  1345. X#define            DRAW_SPLINE        10
  1346. X#define            DRAW_CLOSEDSPLINE    11
  1347. X#define            DRAW_COMPOUND        13
  1348. X
  1349. Xextern F_arrow        *forward_arrow(), *backward_arrow();
  1350. Xextern int        figure_modified;
  1351. Xextern int        errno;
  1352. Xextern char        *sys_errlist[];
  1353. Xextern int        sys_nerr, errno;
  1354. X
  1355. Xstatic F_ellipse    *read_ellipseobject();
  1356. Xstatic F_line        *read_lineobject();
  1357. Xstatic F_text        *read_textobject();
  1358. Xstatic F_spline        *read_splineobject();
  1359. Xstatic F_arc        *read_arcobject();
  1360. Xstatic F_compound    *read_compoundobject();
  1361. X
  1362. Xextern int        line_no;
  1363. Xextern int        num_object;
  1364. X
  1365. Xint
  1366. Xread_1_3_objects(fp, obj)
  1367. XFILE        *fp;
  1368. XF_compound    *obj;
  1369. X{
  1370. X    F_ellipse    *e, *le = NULL;
  1371. X    F_line        *l, *ll = NULL;
  1372. X    F_text        *t, *lt = NULL;
  1373. X    F_spline    *s, *ls = NULL;
  1374. X    F_arc        *a, *la = NULL;
  1375. X    F_compound    *c, *lc = NULL;
  1376. X    int         n;
  1377. X    int         object, pixperinch, canvaswid, canvasht, coord_sys;
  1378. X
  1379. X    n = fscanf(fp,"%d%d%d%d\n", &pixperinch, &coord_sys, &canvaswid, &canvasht);
  1380. X    if (n != 4) {
  1381. X        put_msg("Incorrect format in the first line in input file");
  1382. X        return(-1);
  1383. X        }
  1384. X    obj->nwcorner.x = pixperinch;
  1385. X    obj->nwcorner.y = coord_sys;
  1386. X    while (fscanf(fp, "%d", &object) == 1) {
  1387. X        switch (object) {
  1388. X        case O_POLYLINE :
  1389. X            if ((l = read_lineobject(fp)) == NULL) return(-1);
  1390. X            if (ll)
  1391. X            ll = (ll->next = l);
  1392. X            else
  1393. X            ll = obj->lines = l;
  1394. X            num_object++;
  1395. X            break;
  1396. X        case O_SPLINE :
  1397. X            if ((s = read_splineobject(fp)) == NULL) return(-1);
  1398. X            if (ls)
  1399. X            ls = (ls->next = s);
  1400. X            else
  1401. X            ls = obj->splines = s;
  1402. X            num_object++;
  1403. X            break;
  1404. X        case O_ELLIPSE :
  1405. X            if ((e = read_ellipseobject(fp)) == NULL) return(-1);
  1406. X            if (le)
  1407. X            le = (le->next = e);
  1408. X            else
  1409. X            le = obj->ellipses = e;
  1410. X            num_object++;
  1411. X            break;
  1412. X        case O_ARC :
  1413. X            if ((a = read_arcobject(fp)) == NULL) return(-1);
  1414. X            if (la)
  1415. X            la = (la->next = a);
  1416. X            else
  1417. X            la = obj->arcs = a;
  1418. X            num_object++;
  1419. X            break;
  1420. X        case O_TEXT :
  1421. X            if ((t = read_textobject(fp)) == NULL) return(-1);
  1422. X            if (lt)
  1423. X            lt = (lt->next = t);
  1424. X            else
  1425. X            lt = obj->texts = t;
  1426. X            num_object++;
  1427. X            break;
  1428. X        case O_COMPOUND :
  1429. X            if ((c = read_compoundobject(fp)) == NULL) return(-1);
  1430. X            if (lc)
  1431. X            lc = (lc->next = c);
  1432. X            else
  1433. X            lc = obj->compounds = c;
  1434. X            num_object++;
  1435. X            break;
  1436. X        default:
  1437. X            put_msg("Incorrect object code %d", object);
  1438. X            return(-1);
  1439. X        } /*  switch */
  1440. X        } /*  while */
  1441. X    if (feof(fp))
  1442. X        return(0);
  1443. X    else
  1444. X        return(errno);
  1445. X    }
  1446. X
  1447. Xstatic F_arc *
  1448. Xread_arcobject(fp)
  1449. XFILE    *fp;
  1450. X{
  1451. X    F_arc    *a;
  1452. X    int    f, b, h, w, n;
  1453. X
  1454. X    Arc_malloc(a);
  1455. X    a->type = T_3_POINTS_ARC;
  1456. X    a->color = BLACK;
  1457. X    a->depth = 0;
  1458. X    a->pen = NULL;
  1459. X    a->for_arrow = NULL;
  1460. X    a->back_arrow = NULL;
  1461. X    a->next = NULL;
  1462. X    n = fscanf(fp, " %d %d %d %lf %d %d %d %d %d %lf %lf %d %d %d %d %d %d\n",
  1463. X        &a->type, &a->style, &a->thickness, 
  1464. X        &a->style_val, &a->direction, &f, &b,
  1465. X        &h, &w, &a->center.x, &a->center.y, 
  1466. X        &a->point[0].x, &a->point[0].y, 
  1467. X        &a->point[1].x, &a->point[1].y, 
  1468. X        &a->point[2].x, &a->point[2].y);
  1469. X    if (n != 17) {
  1470. X        put_msg("incomplete arc data");
  1471. X        free((char*)a);
  1472. X        return(NULL);
  1473. X        }
  1474. X    if (f) {
  1475. X        a->for_arrow = forward_arrow();
  1476. X        a->for_arrow->wid = w;
  1477. X        a->for_arrow->ht = h;
  1478. X        }
  1479. X    if (b) {
  1480. X        a->back_arrow = backward_arrow();
  1481. X        a->back_arrow->wid = w;
  1482. X        a->back_arrow->ht = h;
  1483. X        }
  1484. X    return(a);
  1485. X    }
  1486. X
  1487. Xstatic F_compound *
  1488. Xread_compoundobject(fp)
  1489. XFILE    *fp;
  1490. X{
  1491. X    F_arc        *a, *la = NULL;
  1492. X    F_ellipse    *e, *le = NULL;
  1493. X    F_line        *l, *ll = NULL;
  1494. X    F_spline    *s, *ls = NULL;
  1495. X    F_text        *t, *lt = NULL;
  1496. X    F_compound    *com, *c, *lc = NULL;
  1497. X    int         n, object;
  1498. X
  1499. X    Compound_malloc(com);
  1500. X    com->arcs = NULL;
  1501. X    com->ellipses = NULL;
  1502. X    com->lines = NULL;
  1503. X    com->splines = NULL;
  1504. X    com->texts = NULL;
  1505. X    com->compounds = NULL;
  1506. X    com->next = NULL;
  1507. X    n = fscanf(fp, " %d %d %d %d\n", &com->nwcorner.x, &com->nwcorner.y,
  1508. X        &com->secorner.x, &com->secorner.y);
  1509. X    if (n != 4) {
  1510. X        put_msg("Incorrect compound object format");
  1511. X        return(NULL);
  1512. X        }
  1513. X    while (fscanf(fp, "%d", &object) == 1) {
  1514. X        switch (object) {
  1515. X        case O_POLYLINE :
  1516. X            if ((l = read_lineobject(fp)) == NULL) { 
  1517. X            free_line(&l);
  1518. X            return(NULL);
  1519. X            }
  1520. X            if (ll)
  1521. X            ll = (ll->next = l);
  1522. X            else
  1523. X            ll = com->lines = l;
  1524. X            break;
  1525. X        case O_SPLINE :
  1526. X            if ((s = read_splineobject(fp)) == NULL) { 
  1527. X            free_spline(&s);
  1528. X            return(NULL);
  1529. X            }
  1530. X            if (ls)
  1531. X            ls = (ls->next = s);
  1532. X            else
  1533. X            ls = com->splines = s;
  1534. X            break;
  1535. X        case O_ELLIPSE :
  1536. X            if ((e = read_ellipseobject(fp)) == NULL) { 
  1537. X            free_ellipse(&e);
  1538. X            return(NULL);
  1539. X            }
  1540. X            if (le)
  1541. X            le = (le->next = e);
  1542. X            else
  1543. X            le = com->ellipses = e;
  1544. X            break;
  1545. X        case O_ARC :
  1546. X            if ((a = read_arcobject(fp)) == NULL) { 
  1547. X            free_arc(&a);
  1548. X            return(NULL);
  1549. X            }
  1550. X            if (la)
  1551. X            la = (la->next = a);
  1552. X            else
  1553. X            la = com->arcs = a;
  1554. X            break;
  1555. X        case O_TEXT :
  1556. X            if ((t = read_textobject(fp)) == NULL) { 
  1557. X            free_text(&t);
  1558. X            return(NULL);
  1559. X            }
  1560. X            if (lt)
  1561. X            lt = (lt->next = t);
  1562. X            else
  1563. X            lt = com->texts = t;
  1564. X            break;
  1565. X        case O_COMPOUND :
  1566. X            if ((c = read_compoundobject(fp)) == NULL) { 
  1567. X            free_compound(&c);
  1568. X            return(NULL);
  1569. X            }
  1570. X            if (lc)
  1571. X            lc = (lc->next = c);
  1572. X            else
  1573. X            lc = com->compounds = c;
  1574. X            break;
  1575. X        case O_END_COMPOUND :
  1576. X            return(com);
  1577. X        } /*  switch */
  1578. X        }
  1579. X    if (feof(fp))
  1580. X        return(com);
  1581. X    else {
  1582. X        put_msg("Format error: %s", sys_errlist[errno]);
  1583. X        return(NULL);
  1584. X        }
  1585. X    }
  1586. X
  1587. Xstatic F_ellipse *
  1588. Xread_ellipseobject(fp)
  1589. XFILE    *fp;
  1590. X{
  1591. X    F_ellipse    *e;
  1592. X    int        n, t;
  1593. X
  1594. X    Ellipse_malloc(e);
  1595. X    e->color = BLACK;
  1596. X    e->angle = 0.0;
  1597. X    e->depth = 0;
  1598. X    e->pen = NULL;
  1599. X    e->area_fill = NULL;
  1600. X    e->next = NULL;
  1601. X    n = fscanf(fp," %d %d %d %lf %d %d %d %d %d %d %d %d %d\n", 
  1602. X        &t, &e->style,
  1603. X        &e->thickness, &e->style_val, &e->direction, 
  1604. X        &e->center.x, &e->center.y, 
  1605. X        &e->radiuses.x, &e->radiuses.y, 
  1606. X        &e->start.x, &e->start.y, 
  1607. X        &e->end.x, &e->end.y);
  1608. X    if (n != 13) {
  1609. X        put_msg("incomplete ellipse data");
  1610. X        free((char*)e);
  1611. X        return(NULL);
  1612. X        }
  1613. X    if (t == DRAW_ELLIPSE_BY_RAD)
  1614. X        e->type = T_ELLIPSE_BY_RAD;
  1615. X    else if (t == DRAW_ELLIPSE_BY_DIA)
  1616. X        e->type = T_ELLIPSE_BY_DIA;
  1617. X    else if (t == DRAW_CIRCLE_BY_RAD)
  1618. X        e->type = T_CIRCLE_BY_RAD;
  1619. X    else
  1620. X        e->type = T_CIRCLE_BY_DIA;
  1621. X    return(e);
  1622. X    }
  1623. X
  1624. Xstatic F_line *
  1625. Xread_lineobject(fp)
  1626. XFILE            *fp;
  1627. X{
  1628. X    F_line    *l;
  1629. X    F_point    *p, *q;
  1630. X    int    f, b, h, w, n, t, x, y;
  1631. X
  1632. X    Line_malloc(l);
  1633. X    l->color = BLACK;
  1634. X    l->depth = 0;
  1635. X    l->pen = NULL;
  1636. X    l->area_fill = NULL;
  1637. X    l->for_arrow = NULL;
  1638. X    l->back_arrow = NULL;
  1639. X    l->next = NULL;
  1640. X    l->points = Point_malloc(p);
  1641. X    n = fscanf(fp, " %d %d %d %lf %d %d %d %d %d %d", &t, 
  1642. X        &l->style, &l->thickness, &l->style_val,
  1643. X        &f, &b, &h, &w, &p->x, &p->y);
  1644. X    if (n != 10) {
  1645. X        put_msg("incomplete line data");
  1646. X        free((char*)l);
  1647. X        return(NULL);
  1648. X        }
  1649. X    if (t == DRAW_POLYLINE)
  1650. X        l->type = T_POLYLINE;
  1651. X    else if (t == DRAW_POLYGON)
  1652. X        l->type = T_POLYGON;
  1653. X    else
  1654. X        l->type = T_BOX;
  1655. X    if (f) {
  1656. X        l->for_arrow = forward_arrow();
  1657. X        l->for_arrow->wid = w;
  1658. X        l->for_arrow->ht = h;
  1659. X        }
  1660. X    if (b) {
  1661. X        l->back_arrow = backward_arrow();
  1662. X        l->back_arrow->wid = w;
  1663. X        l->back_arrow->ht = h;
  1664. X        }
  1665. X    for (;;) {
  1666. X        if (fscanf(fp, " %d %d", &x, &y) != 2) {
  1667. X        put_msg("incomplete line object");
  1668. X        free_linestorage(l);
  1669. X        return(NULL);
  1670. X        }
  1671. X        if (x == 9999) break;
  1672. X        Point_malloc(q);
  1673. X        q->x = x;
  1674. X        q->y = y;
  1675. X        q->next = NULL;
  1676. X        p->next = q;
  1677. X        p = q;
  1678. X        }
  1679. X    return(l);
  1680. X    }
  1681. X
  1682. Xstatic F_spline *
  1683. Xread_splineobject(fp)
  1684. XFILE    *fp;
  1685. X{
  1686. X    F_spline    *s;
  1687. X    F_point        *p, *q;
  1688. X    int        f, b, h, w, n, t, x, y;
  1689. X
  1690. X    Spline_malloc(s);
  1691. X    s->color = BLACK;
  1692. X    s->depth = 0;
  1693. X    s->pen = NULL;
  1694. X    s->area_fill = NULL;
  1695. X    s->for_arrow = NULL;
  1696. X    s->back_arrow = NULL;
  1697. X    s->controls = NULL;
  1698. X    s->next = NULL;
  1699. X    s->points = Point_malloc(p);
  1700. X    n = fscanf(fp, " %d %d %d %lf %d %d %d %d %d %d", 
  1701. X            &t, &s->style, &s->thickness, &s->style_val,
  1702. X            &f, &b,
  1703. X            &h, &w, &p->x, &p->y);
  1704. X    if (n != 10) {
  1705. X        put_msg("incomplete spline data");
  1706. X        free((char*)s);
  1707. X        return(NULL);
  1708. X        }
  1709. X    if (t == DRAW_CLOSEDSPLINE)
  1710. X        s->type = T_CLOSED_NORMAL;
  1711. X    else
  1712. X        s->type = T_OPEN_NORMAL;
  1713. X    if (f) {
  1714. X        s->for_arrow = forward_arrow();
  1715. X        s->for_arrow->wid = w;
  1716. X        s->for_arrow->ht = h;
  1717. X        }
  1718. X    if (b) {
  1719. X        s->back_arrow = backward_arrow();
  1720. X        s->back_arrow->wid = w;
  1721. X        s->back_arrow->ht = h;
  1722. X        }
  1723. X    for (;;) {
  1724. X        if (fscanf(fp, " %d %d", &x, &y) != 2) {
  1725. X        put_msg("incomplete spline object");
  1726. X        free_splinestorage(s);
  1727. X        return(NULL);
  1728. X        };
  1729. X        if (x == 9999) break;
  1730. X        Point_malloc(q);
  1731. X        q->x = x;
  1732. X        q->y = y;
  1733. X        q->next = NULL;
  1734. X        p->next = q;
  1735. X        p = q;
  1736. X        }
  1737. X    return(s);
  1738. X    }
  1739. X
  1740. Xstatic F_text *
  1741. Xread_textobject(fp)
  1742. XFILE    *fp;
  1743. X{
  1744. X    F_text    *t;
  1745. X    int    n;
  1746. X    char    buf[128];
  1747. X
  1748. X    Text_malloc(t);
  1749. X    t->type = T_LEFT_JUSTIFIED;
  1750. X    t->style = PLAIN;
  1751. X    t->color = BLACK;
  1752. X    t->depth = 0;
  1753. X    t->pen = NULL;
  1754. X    t->angle = 0.0;
  1755. X    t->next = NULL;
  1756. X    n = fscanf(fp," %d %d %d %d %d %d %d %[^\n]", &t->font, 
  1757. X        &t->size, &t->style, &t->height, &t->length, 
  1758. X        &t->base_x, &t->base_y, buf);
  1759. X    if (n != 8) {
  1760. X        put_msg("incomplete text data");
  1761. X        free((char*)t);
  1762. X        return(NULL);
  1763. X        }
  1764. X    t->cstring = (char *) calloc((unsigned)(strlen(buf)+1), sizeof(char));
  1765. X    if (t->cstring == NULL) {
  1766. X        put_msg(Err_mem);
  1767. X        free((char*) t);
  1768. X        return(NULL);
  1769. X        }
  1770. X    (void)strcpy(t->cstring, buf);
  1771. X    if (t->size == 0) t->size = 18;
  1772. X    return(t);
  1773. X    }
  1774. END_OF_FILE
  1775. if test 9833 -ne `wc -c <'transfig/fig2dev/read1_3.c'`; then
  1776.     echo shar: \"'transfig/fig2dev/read1_3.c'\" unpacked with wrong size!
  1777. fi
  1778. # end of 'transfig/fig2dev/read1_3.c'
  1779. fi
  1780. echo shar: End of archive 2 \(of 6\).
  1781. cp /dev/null ark2isdone
  1782. MISSING=""
  1783. for I in 1 2 3 4 5 6 ; do
  1784.     if test ! -f ark${I}isdone ; then
  1785.     MISSING="${MISSING} ${I}"
  1786.     fi
  1787. done
  1788. if test "${MISSING}" = "" ; then
  1789.     echo You have unpacked all 6 archives.
  1790.     rm -f ark[1-9]isdone
  1791. else
  1792.     echo You still need to unpack the following archives:
  1793.     echo "        " ${MISSING}
  1794. fi
  1795. ##  End of shell archive.
  1796. exit 0
  1797. -- 
  1798. Please send comp.sources.unix-related mail to rsalz@uunet.uu.net.
  1799. Use a domain-based address or give alternate paths, or you may lose out.
  1800.