home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2007 < prev    next >
Internet Message Format  |  1990-12-28  |  26KB
  1. From: hot@integow.uucp (Roland van Hout)
  2. Newsgroups: alt.sources
  3. Subject: PD plot(4) librarys (and hercules driver for interactive 386) part 4 of 9
  4. Message-ID: <1392@integow.uucp>
  5. Date: 28 Oct 90 03:55:33 GMT
  6.  
  7.  
  8.  
  9. #!/bin/sh
  10. # This is part 04 of a multipart archive
  11. if touch 2>&1 | fgrep '[-amc]' > /dev/null
  12.  then TOUCH=touch
  13.  else TOUCH=true
  14. fi
  15. # ============= libplot/lp/ib_map.c ==============
  16. echo "x - extracting libplot/lp/ib_map.c (Text)"
  17. sed 's/^X//' << 'SHAR_EOF' > libplot/lp/ib_map.c &&
  18. X/*
  19. X * ib_map.c
  20. X *
  21. X * Copyright (c) 1988 Environmental Defense Fund, Inc.
  22. X */
  23. X
  24. X#include <stdio.h>
  25. X#include "const.h"
  26. X#include "fillcnst.h"
  27. X
  28. X#ifdef TESTVER
  29. X#include <signal.h>
  30. X#include "dbgvars.h"
  31. X#endif
  32. X
  33. X#define XLIM 94            /* 47 for 1/2 pg output, 94 for full page
  34. X                 * output */
  35. X#define YLIM 480        /* 240/480 for half/full pg output, mode K... */
  36. X /* ...480/960 for half/full pg output, mode L */
  37. X#define MODE 'Z'        /* 'K' / 'L': 60 dots per in / 120 dots per
  38. X                 * in 'Z' quad density 240 dots per in */
  39. X
  40. X#define LEFT_CUTOFF  0
  41. X
  42. X/*
  43. X * Constants
  44. X * SCALEX and SCALEY have been changed to vars, set in init_map,
  45. X * to simplify quick changes of scale, depending on XLIM, YLIM
  46. X */
  47. X
  48. X#define ROUNDER 0.0
  49. X
  50. X#ifndef TESTVER
  51. X#define PUT_BIT(x,y)    map[(x >> 3) + (XLIM * y)] |= BITS[x & 7]
  52. X#endif
  53. X
  54. X#define ABS(x) ((x) > 0.0 ? (x) : -(x))
  55. X
  56. Xlong    MAP_MAX;
  57. Xdouble  SCALEX,
  58. X        SCALEY;            /* <<<<<<<<<<<< */
  59. Xchar    BITS[] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
  60. Xextern char map[];        /* in maps.c */
  61. X
  62. X
  63. X/*******************************
  64. X * catch(), catchi() were here *
  65. X *******************************/
  66. X
  67. X#ifdef TESTVER
  68. XPUT_BIT(x, y)
  69. X    int     x,
  70. X            y;
  71. X{
  72. X    int     offset;
  73. X
  74. X    offset = ((x >> 3) + (XLIM * y));
  75. X    if ((offset >= (MAP_MAX)) || (offset < 0)) {
  76. X    fprintf(stderr,
  77. X        "PUTBIT offset overflow: %d;  x: %d;  y: %d\n", offset, x, y);
  78. X    fprintf(errfp,
  79. X        "PUTBIT offset overflow: %d;  x: %d;  y: %d\n", offset, x, y);
  80. X    fclose(errfp);
  81. X    dump_map(TRUE);
  82. X    exit(1);
  83. X    }
  84. X    map[offset] |= BITS[x & 7];
  85. X}
  86. X
  87. X#endif
  88. X
  89. X
  90. Xib_put_seg(p1, p2)
  91. X    POINT   p1,
  92. X            p2;
  93. X{
  94. X    double  diffx,
  95. X            diffy,
  96. X            change_ratio;
  97. X    register int x,
  98. X            y;
  99. X    register int inc;
  100. X
  101. X#if 0
  102. X    signal(SIGSEGV, catch);
  103. X    signal(SIGINT, catchi);
  104. X#endif
  105. X
  106. X#ifdef TESTVER
  107. X    if (debug2 || debug2x) {
  108. X    fprintf(errfp, "p1 ( %d, %d );   p2 ( %d, %d )\n",
  109. X        p1.x, p1.y, p2.x, p2.y);
  110. X    }
  111. X#endif
  112. X
  113. X    p1.x = SCALEX * (double) p1.x + ROUNDER;
  114. X    p2.x = SCALEX * (double) p2.x + ROUNDER;
  115. X    p1.y = SCALEY * (double) p1.y + ROUNDER;
  116. X    p2.y = SCALEY * (double) p2.y + ROUNDER;
  117. X
  118. X    diffx = p2.x - p1.x;
  119. X    diffy = p2.y - p1.y;
  120. X
  121. X    if (diffx != 0.0 && diffy != 0.0) {    /* neither horiz nor vert */
  122. X    if (ABS(diffx) > ABS(diffy)) {    /* closer to horizontal */
  123. X        inc = (diffx < 0) ? -1 : 1;
  124. X        change_ratio = diffy / diffx;
  125. X        for (x = p1.x; x != p2.x; x += inc) {
  126. X        y = (x - p1.x) * change_ratio + p1.y + ROUNDER;
  127. X        PUT_BIT(x, y);
  128. X        }
  129. X        PUT_BIT(p2.x, p2.y);
  130. X    } else {        /* closer to vertical */
  131. X        inc = (diffy < 0) ? -1 : 1;
  132. X        change_ratio = diffx / diffy;
  133. X        for (y = p1.y; y != p2.y; y += inc) {
  134. X        x = (y - p1.y) * change_ratio + p1.x + ROUNDER;
  135. X        PUT_BIT(x, y);
  136. X        }
  137. X        PUT_BIT(p2.x, p2.y);
  138. X    }
  139. X    } else {
  140. X    if (diffx) {        /* horizontal line */
  141. X        y = p1.y;
  142. X        inc = (diffx < 0) ? -1 : 1;
  143. X        for (x = p1.x; x != p2.x; x += inc) {
  144. X        PUT_BIT(x, y);
  145. X        }
  146. X        PUT_BIT(p2.x, y);
  147. X    } else {        /* vert. line */
  148. X        x = p1.x;
  149. X        inc = (diffy < 0) ? -1 : 1;
  150. X        for (y = p1.y; y != p2.y; y += inc) {
  151. X        PUT_BIT(x, y);
  152. X        }
  153. X        PUT_BIT(x, p2.y);
  154. X    }
  155. X    }
  156. X}
  157. X
  158. X
  159. Xib_dump_map(to_printer)
  160. X    int     to_printer;
  161. X{
  162. X    int     i;
  163. X    register int j;
  164. X    char    ch;
  165. X    char    hdr[5];
  166. X
  167. X    if (to_printer) {
  168. X    hdr[0] = ESC;
  169. X    hdr[1] = '3';
  170. X    hdr[2] = 24;        /* Line spacing for graphics: 24/216 inch */
  171. X    write(1, hdr, 3);
  172. X    hdr[1] = MODE;        /* 'K'/'L': 480/960 bit image graphics */
  173. X    hdr[2] = (YLIM - LEFT_CUTOFF) & 0xff;    /* n1 = YLIM mod 256 */
  174. X    hdr[3] = ((YLIM - LEFT_CUTOFF) >> 8) & 0xff;    /* n2 = YLIM / 256 */
  175. X
  176. X    for (i = 0; i < XLIM; i++) {
  177. X        write(1, hdr, 4);
  178. X        for (j = LEFT_CUTOFF * XLIM; j < MAP_MAX; j += XLIM) {
  179. X        ch = map[i + j];
  180. X        if (ch == 26)
  181. X            ch = 18;    /* bug in proprinter graphics */
  182. X        if (ch == '\n')
  183. X            ch = 8;    /* prevent add'n of \r to \n */
  184. X        write(1, &ch, 1);
  185. X#ifdef TESTVER
  186. X        if (debug5)
  187. X            fprintf(errfp, "%4d", ch);
  188. X#endif
  189. X        }
  190. X#ifdef TESTVER
  191. X        if (debug5)
  192. X        fprintf(errfp, "%3d*\n", i);
  193. X#endif
  194. X        putchar('\n');    /* LF and CR to end line */
  195. X        putchar('\r');
  196. X        fflush(stdout);
  197. X    }
  198. X
  199. X    /* putchar( '\f' ); *//* form feed */
  200. X#ifdef TESTVER
  201. X    fclose(errfp);
  202. X#endif
  203. X
  204. X    }                /* end if ( to_printer )... */
  205. X}
  206. X
  207. X
  208. Xib_init_map()
  209. X{
  210. X#ifdef TRUESOLID
  211. X    extern double PUs_per_dot;    /* declared in file filltype.c */
  212. X
  213. X#endif
  214. X    register int k;
  215. X    register char *mp;
  216. X
  217. X    MAP_MAX = XLIM * YLIM;
  218. X    SCALEX = (double) (XLIM * 8) / 10366;
  219. X    SCALEY = (double) (YLIM) / 7963;
  220. X
  221. X#ifdef TRUESOLID
  222. X    PUs_per_dot = 1.0 / SCALEX;    /* used by fix_fill() in file filltype.c */
  223. X#endif
  224. X
  225. X    mp = map;
  226. X    for (k = 0; k < MAP_MAX; k++)
  227. X    *mp++ = 0;
  228. X}
  229. SHAR_EOF
  230. $TOUCH -am 0214090289 libplot/lp/ib_map.c &&
  231. chmod 0644 libplot/lp/ib_map.c ||
  232. echo "restore of libplot/lp/ib_map.c failed"
  233. set `wc -c libplot/lp/ib_map.c`;Wc_c=$1
  234. if test "$Wc_c" != "4616"; then
  235.     echo original size 4616, current size $Wc_c
  236. fi
  237. # ============= libplot/lp/itoa.h ==============
  238. echo "x - extracting libplot/lp/itoa.h (Text)"
  239. sed 's/^X//' << 'SHAR_EOF' > libplot/lp/itoa.h &&
  240. X/********************************************************************
  241. X ***** itoa -- Konvertieren Zahlen in ASCII String              *****
  242. X ********************************************************************/
  243. X/* Setzt Zahlen in ASCII String um. Die Umwandlung erfolgt
  244. X   in umgekehrter Reihenfolge. Danach wird der String vertauscht.
  245. X
  246. X   Beispiele:
  247. X    int n;
  248. X    char scrtext[100];
  249. X
  250. X    itoa(n,scrtext);
  251. X        printf("String: %s",&scrtext[0]);
  252. X*/
  253. X
  254. Xitoa(n,scrtext)
  255. Xint n;
  256. Xchar scrtext[];
  257. X{
  258. Xint i,sign,c,j;
  259. X/* 
  260. X    Vorzeichen merken 
  261. X*/
  262. Xif ((sign = n) <0)
  263. X  n= -n;
  264. X/* 
  265. X    Umwandeln 
  266. X*/
  267. Xi=0;
  268. Xdo
  269. X  {
  270. X  scrtext[i++]= n % 10 +'0';
  271. X  }
  272. Xwhile (( n/= 10)>0);
  273. X/* 
  274. X    Vorzeichen setzen 
  275. X*/
  276. Xif (sign <0)
  277. X  scrtext[i++]='-';
  278. Xscrtext[i]='\0';
  279. X/* 
  280. X    Nun Umdrehen 
  281. X*/
  282. Xj= i-1;
  283. Xif (j>0);
  284. X  {
  285. X  for (i=0 ; i<j ; i++ , j--)
  286. X    {
  287. X    c=scrtext[i];
  288. X    scrtext[i]=scrtext[j];
  289. X    scrtext[j]=c;
  290. X    }
  291. X  }
  292. X}
  293. X
  294. X    
  295. SHAR_EOF
  296. $TOUCH -am 1007125888 libplot/lp/itoa.h &&
  297. chmod 0644 libplot/lp/itoa.h ||
  298. echo "restore of libplot/lp/itoa.h failed"
  299. set `wc -c libplot/lp/itoa.h`;Wc_c=$1
  300. if test "$Wc_c" != "879"; then
  301.     echo original size 879, current size $Wc_c
  302. fi
  303. # ============= libplot/lp/label.c ==============
  304. echo "x - extracting libplot/lp/label.c (Text)"
  305. sed 's/^X//' << 'SHAR_EOF' > libplot/lp/label.c &&
  306. X/*
  307. X * do_lb.c
  308. X *
  309. X * Copyright (c) 1988 Environmental Defense Fund, Inc.
  310. X */
  311. X
  312. X#include <stdio.h>
  313. X#include "const.h"
  314. X#include "vars.h"
  315. X#include "dbgvars.h"
  316. X
  317. Xextern POINT plot_char();
  318. X
  319. Xlabel(s)
  320. Xchar *s;
  321. X{
  322. X    char *sp;
  323. X    POINT   l_point;
  324. X    sp=s;
  325. X#ifdef TESTVER
  326. X    int     was_on,
  327. X            xwas_on;        /* for debugging */
  328. X
  329. X    /* turn debug2/2x off, if necessary, for the duration of labeling */
  330. X    if (debug2) {
  331. X    was_on = TRUE;
  332. X    debug2 = FALSE;
  333. X    } else {
  334. X    was_on = FALSE;
  335. X    }
  336. X    if (debug2x) {
  337. X    xwas_on = TRUE;
  338. X    debug2x = FALSE;
  339. X    } else {
  340. X    xwas_on = FALSE;
  341. X    }
  342. X#endif
  343. X
  344. X    l_point = current;
  345. X    if (stand_set_sel)
  346. X    while ((c = *sp++) != NULL) {
  347. X        l_point = plot_char(l_point, c, set_standard);
  348. X    }
  349. X    else
  350. X    while ((c = *sp++) != NULL) {
  351. X        l_point = plot_char(l_point, c, set_alternate);
  352. X    }
  353. X    pen_up = TRUE;
  354. X
  355. X#ifdef TESTVER
  356. X    if (was_on) {
  357. X    debug2 = TRUE;
  358. X    }
  359. X    if (xwas_on) {
  360. X    debug2x = TRUE;
  361. X    }
  362. X#endif
  363. X}
  364. X
  365. SHAR_EOF
  366. $TOUCH -am 1010115088 libplot/lp/label.c &&
  367. chmod 0644 libplot/lp/label.c ||
  368. echo "restore of libplot/lp/label.c failed"
  369. set `wc -c libplot/lp/label.c`;Wc_c=$1
  370. if test "$Wc_c" != "939"; then
  371.     echo original size 939, current size $Wc_c
  372. fi
  373. # ============= libplot/lp/liblj.c ==============
  374. echo "x - extracting libplot/lp/liblj.c (Text)"
  375. sed 's/^X//' << 'SHAR_EOF' > libplot/lp/liblj.c &&
  376. X/*
  377. X * main.c
  378. X *
  379. X * Copyright (c) 1988 Environmental Defense Fund, Inc.
  380. X *
  381. X * hpglplot v2.1
  382. X *
  383. X * Filter to read HPGL commands (Hewlett-Packard Graphics Language,
  384. X * used by HP7475A 6-pen plotter, among others) and produce bit map
  385. X * graphics commands for various printers.
  386. X *
  387. X * Usage: tplotlp -eismh
  388. X * Options: for the lpdriver.c program  
  389. X * -e    produce output for Epson LQ-1500
  390. X * -i    produce output for IBM Proprinter
  391. X * -s    produce output for HP LaserJet+ small
  392. X * -m   produce output for HP LaserJet+ enlarged
  393. X * -h   produce output for HP LaserJet+ extra large
  394. X *
  395. X *
  396. X * Authors:
  397. X *  Mel Brooks
  398. X *    Initial program design, command interpreter, Epson bit-map.
  399. X *  Al Chase
  400. X *    Fill routines, LaserJet and Proprinter bit-maps.
  401. X *  David MacKenzie
  402. X *    Rewrote option parser and makefile, cleaned up.
  403. X */
  404. X/* plot(4) graphics library for a regis terminal for VT240/VT300/GIGI */
  405. Xextern float deltx,delty;
  406. Xfloat pitograd;
  407. X
  408. X#include <math.h>
  409. X#include "plotlp.h"
  410. X
  411. Xclosepl()
  412. X{
  413. Xdump_map(printer);
  414. X}
  415. X
  416. Xspace(x0,y0,x1,y1)
  417. Xint x0,y0,x1,y1;
  418. X{
  419. Xint x,y;
  420. Xpitograd=(180.0/M_PI);
  421. X
  422. Xif (x1>0 && y1>0 && y0<y1 && x0<x1) {
  423. X    x=x1-x0;y=y1-y0;
  424. X    gxscrunch=(7850/(float) x);gyscrunch=(7850/(float) y);
  425. X    offx = -(x0*gxscrunch);offy= -(y0*gyscrunch);
  426. X}
  427. X
  428. X}
  429. X
  430. Xerase()
  431. X{
  432. X/*    printf("\014");*/
  433. X}
  434. X
  435. X
  436. Xarc(x,y,x0,y0,x1,y1)
  437. Xint x,y,x0,y0,x1,y1;
  438. X{
  439. X/*
  440. Xfloat a1,a2,r1,r2;
  441. Xint xo,yo,c1,c2,c;
  442. X    move(x0,y0);
  443. X    if ((x-x0) > 0) {
  444. X        r1=(y-y0)/(x-x0);
  445. X        a1=atan(r1);
  446. X        c1=(a1*pitograd);
  447. X    }
  448. X    else {
  449. X        c1=180;
  450. X    }
  451. X    if ((x-x1) > 0) {
  452. X        r2=(y-y1)/(x-x1);
  453. X        a2=atan(r2);
  454. X        c2=(a2*pitograd);
  455. X    }
  456. X    else {
  457. X        c2=180;
  458. X    }
  459. X        c=c1-c2;
  460. X    xo=(x*gxscrunch);yo=(y*gyscrunch);
  461. X    yo += offy ;xo +=  offx ;
  462. X    printf("\033PpC(A%dC) [%d,%d]\033\\",c,xo,yo);
  463. X
  464. X*/
  465. X}
  466. X/*
  467. X * do_ew.c
  468. X *
  469. X * Copyright (c) 1988 Environmental Defense Fund, Inc.
  470. X 
  471. X
  472. X#include <stdio.h>
  473. X#include <math.h>
  474. X#include "const.h"
  475. X#include "vars.h"
  476. X#ifdef TESTVER
  477. X#  include "dbgvars.h"
  478. X#endif
  479. X
  480. X#define DEGREES_TO_RADIANS 3.1415926535898 / 180.0
  481. X
  482. Xdo_EW()
  483. X{
  484. X    POINT   t,
  485. X            t1;
  486. X    float   radius;
  487. X    int     i_radius,
  488. X            start_angle,
  489. X            sweep_angle,
  490. X            chordangle;
  491. X    int     i;
  492. X
  493. X#ifdef TESTVER
  494. X    int     xwas_on;        /* for debugging 
  495. X
  496. X    /* turn debug2x off, if necessary, for the duration of do_EW() 
  497. X    if (debug2x) {
  498. X    xwas_on = TRUE;
  499. X    debug2x = FALSE;
  500. X    } else {
  501. X    xwas_on = FALSE;
  502. X    }
  503. X#endif
  504. X
  505. X    if (scanf("%f,%d,%d", &radius, &start_angle, &sweep_angle) != 3) {
  506. X    fprintf(stderr, "Odd number of coordinate\n");
  507. X    exit(4);
  508. X    }
  509. X    if ((c = getchar()) != ';') {
  510. X    scanf("%d", &chordangle);
  511. X    getchar();
  512. X    } else {
  513. X    chordangle = chord_angle;
  514. X    }
  515. X
  516. X    if (sweep_angle < 0)
  517. X    chordangle = -1 * (abs(chordangle));
  518. X
  519. X    start_angle %= 360;
  520. X    if (sweep_angle > 360)
  521. X    sweep_angle = 360;
  522. X    else if (sweep_angle < -360)
  523. X    sweep_angle = -360;
  524. X
  525. X    if (scaling) {
  526. X    i_radius = (int) (radius * x_scaler);
  527. X    if (i_radius < 0)
  528. X        i_radius -= 1;
  529. X    } else
  530. X    i_radius = (int) radius;
  531. X
  532. X    /* plot starting radius 
  533. X    t.x = (int) ((double) radius * cos((double) start_angle *
  534. X        DEGREES_TO_RADIANS) + 0.5) + current.x;
  535. X    t.y = (int) ((double) radius * sin((double) start_angle *
  536. X        DEGREES_TO_RADIANS) + 0.5) + current.y;
  537. X    put_seg(current, t);
  538. X
  539. X    /* plot chords up to (but not incl) sweep_angle 
  540. X    for (i = chordangle; abs(i) < abs(sweep_angle); i += chordangle) {
  541. X    t1.x = (int) ((double) radius * cos((double) (start_angle + i)
  542. X        * DEGREES_TO_RADIANS) + 0.5) + current.x;
  543. X    t1.y = (int) ((double) radius * sin((double) (start_angle + i)
  544. X        * DEGREES_TO_RADIANS) + 0.5) + current.y;
  545. X    put_seg(t, t1);
  546. X    t = t1;
  547. X    }
  548. X
  549. X    /* plot remaining (partial?) chord needed to make up the full sweep angle 
  550. X    t1.x = (int) ((double) radius * cos((double) (start_angle + sweep_angle)
  551. X        * DEGREES_TO_RADIANS) + 0.5) + current.x;
  552. X    t1.y = (int) ((double) radius * sin((double) (start_angle + sweep_angle)
  553. X        * DEGREES_TO_RADIANS) + 0.5) + current.y;
  554. X    put_seg(t, t1);
  555. X    t = t1;
  556. X
  557. X    /* plot ending radius 
  558. X    put_seg(t1, current);
  559. X
  560. X#ifdef TESTVER            /* reset debug2x if necessary 
  561. X    if (xwas_on) {
  562. X    debug2x = TRUE;
  563. X    }
  564. X#endif
  565. X}
  566. X*/
  567. X
  568. Xdot(xi,yi,dx,n,pat)
  569. Xint xi,yi,dx,n,pat[256];
  570. X{
  571. X}
  572. X
  573. Xpoint(x,y)
  574. Xint x,y;
  575. X{
  576. X      move(x,y);
  577. X      cont(x,y);
  578. X}
  579. X
  580. X
  581. Xline (x1, y1, x2, y2)
  582. Xint x1,y1,x2,y2;
  583. X{
  584. X    move(x1,y1);
  585. X    cont(x2,y2);
  586. X}
  587. X
  588. X
  589. X
  590. X
  591. SHAR_EOF
  592. $TOUCH -am 1011095088 libplot/lp/liblj.c &&
  593. chmod 0644 libplot/lp/liblj.c ||
  594. echo "restore of libplot/lp/liblj.c failed"
  595. set `wc -c libplot/lp/liblj.c`;Wc_c=$1
  596. if test "$Wc_c" != "4267"; then
  597.     echo original size 4267, current size $Wc_c
  598. fi
  599. # ============= libplot/lp/linemod.c ==============
  600. echo "x - extracting libplot/lp/linemod.c (Text)"
  601. sed 's/^X//' << 'SHAR_EOF' > libplot/lp/linemod.c &&
  602. X#include "plotlp.h"
  603. X
  604. Xlinemod(s)
  605. Xchar *s;
  606. X{
  607. X    line_type = SOLID;
  608. X  if (strcmp(s,"dotted")==0) {
  609. X    line_type=DOTS;
  610. X      }
  611. X  else if (strcmp(s,"solid")==0) {
  612. X    line_type = SOLID;
  613. X      }
  614. X      else if (strcmp(s,"longdashed")==0) {
  615. X          line_type=BROKN_2DASH;
  616. X          }
  617. X         else if (strcmp(s,"shortdashed")==0) {
  618. X             line_type=SHORT_DASH;
  619. X             }
  620. X            else if (strcmp(s,"dotdashed")==0) {
  621. X                line_type=BROKN_DASH;
  622. X                }
  623. X}
  624. X
  625. SHAR_EOF
  626. $TOUCH -am 1010110488 libplot/lp/linemod.c &&
  627. chmod 0644 libplot/lp/linemod.c ||
  628. echo "restore of libplot/lp/linemod.c failed"
  629. set `wc -c libplot/lp/linemod.c`;Wc_c=$1
  630. if test "$Wc_c" != "399"; then
  631.     echo original size 399, current size $Wc_c
  632. fi
  633. # ============= libplot/lp/lj_map.c ==============
  634. echo "x - extracting libplot/lp/lj_map.c (Text)"
  635. sed 's/^X//' << 'SHAR_EOF' > libplot/lp/lj_map.c &&
  636. X/*
  637. X * lj_map.c
  638. X *
  639. X * Copyright (c) 1988 Environmental Defense Fund, Inc.
  640. X */
  641. X
  642. X#include <stdio.h>
  643. X#include "const.h"
  644. X#include "vars.h"
  645. X#include "fillcnst.h"
  646. X#include "itoa.h"
  647. X
  648. X#ifdef TESTVER
  649. X#include <signal.h>
  650. X#endif
  651. X
  652. X/*
  653. X * Origin is at lower left corner.
  654. X * Bytes of raster data are oriented along the x-axis, hi bit at left:
  655. X *       (0,0) is bit 7 of byte 0;
  656. X *       (7,0) is bit 0 of byte 0;
  657. X *       (16,0) is bit 7 of byte 2;
  658. X *       (16,3) is bit 7 of byte (2 + Xlim*3)
  659. X */
  660. X
  661. X/*
  662. X * Constants
  663. X * Ylim = 1440 dot rows, plus a couple extra for rounding error
  664. X#define Ylim 1442
  665. X#define Xlim  235
  666. X#define scaleX  0.180859
  667. X#define scaleY  0.180859
  668. X
  669. X#define Ylim 1841
  670. X#define Xlim  300
  671. X
  672. X/* scaleX = scaleY = number of dots per plotter unit
  673. X                   = 1440 dot rows in y-direction / 7962 PU's in y-dir 
  674. X#define scaleX  0.231205
  675. X#define scaleY  0.231205
  676. X#define rounder 0.0
  677. X [hot@mh.nl] */
  678. X
  679. Xstatic int Ylim,Xlim,Ylim8;
  680. Xstatic double scaleX,scaleY,rounder;
  681. X
  682. X#define ABS(x) ((x) > 0.0 ? (x) : -(x))
  683. X
  684. X/* move bit map to maps.c for combined printer version --- */
  685. X#if 0
  686. Xchar    map[Xlim * Ylim];
  687. X
  688. X#endif
  689. Xextern char map[];
  690. X
  691. Xstatic char BITS[] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
  692. X#ifdef TESTVER
  693. X#define PUT_BIT(x, y)  map[(tempindex = (tempx = (x >> 3)) + ((tempy = y) * Xlim))] |= BITS[x & 7];
  694. X#else
  695. X#define P_BIT(x, y)  map[(x >> 3) + (y * Xlim)] |= BITS[x & 7]; 
  696. XPUT_BIT(x, y)
  697. Xint x,y;
  698. X{
  699. Xint saveit;
  700. Xif (printer == LASERHIGH || printer == LASERMED) { 
  701. X    saveit=x;x=y;y=Ylim-saveit;
  702. X}
  703. XP_BIT(x,y);
  704. X}
  705. X
  706. X#endif
  707. X
  708. X
  709. X#ifdef TESTVER
  710. Xstatic int tempindex,
  711. X        tempx,
  712. X        tempy;
  713. Xstatic POINT tempp1,
  714. X        tempp2;
  715. X
  716. Xlj_catch()
  717. X{
  718. X    fprintf(stderr, "Segmentation violation\n");
  719. X    fprintf(stderr, "tempindex = %d x = %d y = %d p1 = %d,%d p2 = %d,%d\n",
  720. X    tempindex, tempx, tempy, tempp1.x, tempp1.y, tempp2.x, tempp2.y);
  721. X    lj_dump_map(FALSE);
  722. X    exit(1);
  723. X}
  724. X
  725. Xljcatchi()
  726. X{
  727. X    lj_dump_map(FALSE);
  728. X    exit(1);
  729. X}
  730. X
  731. X#endif
  732. X
  733. Xlj_put_seg(p1, p2)
  734. X    POINT   p1,
  735. X            p2;
  736. X{
  737. X    double  diffx,
  738. X            diffy,
  739. X            change_ratio;
  740. X    register int x,
  741. X            y;
  742. X    register int inc;
  743. X
  744. X#ifdef TESTVER
  745. X#if 0
  746. X    signal(SIGSEGV, lj_catch);
  747. X    signal(SIGINT, ljcatchi);
  748. X#endif
  749. X    tempp1 = p1;
  750. X    tempp2 = p2;
  751. X#endif
  752. X
  753. X    p1.x = scaleX * (double) p1.x + rounder;
  754. X    p2.x = scaleX * (double) p2.x + rounder;
  755. X    p1.y = scaleY * (double) p1.y + rounder;
  756. X    p2.y = scaleY * (double) p2.y + rounder;
  757. X
  758. X    diffx = p2.x - p1.x;
  759. X    diffy = p2.y - p1.y;
  760. X
  761. X    if (diffx != 0.0 && diffy != 0.0) {
  762. X    if (ABS(diffx) > ABS(diffy)) {
  763. X        inc = (diffx < 0) ? -1 : 1;
  764. X        change_ratio = diffy / diffx;
  765. X        for (x = p1.x; x != p2.x; x += inc) {
  766. X        y = (x - p1.x) * change_ratio + p1.y + rounder;
  767. X        PUT_BIT(x, y);
  768. X        }
  769. X        PUT_BIT(p2.x, p2.y);
  770. X    } else {
  771. X        inc = (diffy < 0) ? -1 : 1;
  772. X        change_ratio = diffx / diffy;
  773. X        for (y = p1.y; y != p2.y; y += inc) {
  774. X        x = (y - p1.y) * change_ratio + p1.x + rounder;
  775. X        PUT_BIT(x, y);
  776. X        }
  777. X        PUT_BIT(p2.x, p2.y);
  778. X    }
  779. X    } else {
  780. X    if (diffx) {        /* horizontal line */
  781. X        y = p1.y;
  782. X        inc = (diffx < 0) ? -1 : 1;
  783. X        for (x = p1.x; x != p2.x; x += inc) {
  784. X        PUT_BIT(x, y);
  785. X        }
  786. X        PUT_BIT(p2.x, y);
  787. X    } else {
  788. X        x = p1.x;
  789. X        inc = (diffy < 0) ? -1 : 1;
  790. X        for (y = p1.y; y != p2.y; y += inc) {
  791. X        PUT_BIT(x, y);
  792. X        }
  793. X        PUT_BIT(x, p2.y);
  794. X    }
  795. X    }
  796. X}
  797. X
  798. X
  799. Xlj_dump_map(to_printer)
  800. X    int     to_printer;
  801. X{
  802. X    register int r;
  803. X    char    ccount[8];/* [hot@mh.nl] */
  804. X    char    hdr[80];/* [hot@mh.nl] */
  805. X    char   *mp = map;
  806. X    char   *p,leeg,
  807. X           *maxp;        /* for LF-char test */
  808. X    short int schrijfspaar,hdr_length;
  809. X    short int county,countx,countsx,countdif;/* [hot@mh.nl] */
  810. X
  811. X    if (to_printer) {
  812. X    hdr[0] = ESC;
  813. X
  814. X    /* reset printer */
  815. X    hdr_length = 1 + n_strcpy(&hdr[1], "E");
  816. X    write(1, hdr, hdr_length);
  817. X
  818. X    /* set printer to interpret a '\n' char to a '\r\n' pair */
  819. X    hdr_length = 1 + n_strcpy(&hdr[1], "&k2G");
  820. X    write(1, hdr, hdr_length);
  821. X
  822. X    /* raster graphics resolution: 300 dots/in */
  823. X    hdr_length = 1 + n_strcpy(&hdr[1], "*t300R");
  824. X    write(1, hdr, hdr_length);
  825. X
  826. X    if (printer == LASERLOW) {
  827. X        /* set cursor to col 11  */
  828. X        hdr_length = 1 + n_strcpy(&hdr[1], "&a11C");
  829. X        write(1, hdr, hdr_length);
  830. X
  831. X            /* set cursor to row 10 */
  832. X        hdr_length = 1 + n_strcpy(&hdr[1], "&a10R");
  833. X        write(1, hdr, hdr_length);
  834. X        /* [hot@mh.nl] */
  835. X    }
  836. X
  837. X    /* start graphics at current cursor posn */
  838. X    hdr_length = 1 + n_strcpy(&hdr[1], "*r1A");
  839. X    write(1, hdr, hdr_length);
  840. X
  841. X    if (printer==LASERLOW) {
  842. X        /* transfer-line-of-graphics escape sequence -- 235 is Xlim */
  843. X        hdr_length = 1 + n_strcpy(&hdr[1], "*b");
  844. X        itoa(Xlim,ccount);
  845. X        hdr_length += n_strcpy(&hdr[hdr_length], ccount);
  846. X        hdr_length += n_strcpy(&hdr[hdr_length], "W");
  847. X    }
  848. X
  849. X    /*
  850. X     * write Ylim rows, each row is Xlim bytes starting at offset r from
  851. X     * map[0] 
  852. X     */
  853. X    for (r = (Ylim - 1) * Xlim,county=1; r >= 0; r -= Xlim,county++) {
  854. X        /* check this row for LF-chars; replace with byte value of 8 */
  855. X        p = mp + r;
  856. X        maxp = p + Xlim;
  857. X        leeg=0;    /* [hot@mh.nl] */
  858. X        countx=0;
  859. X        schrijfspaar=FALSE;
  860. X        while (p < maxp) {
  861. X        if (*p == '\n') *p = '\010';
  862. X        if (printer != LASERLOW){
  863. X        if (*p == '\000') {
  864. X            if (schrijfspaar==TRUE) {
  865. X            /* transfer-line-of-graphics escape sequence -- 235 is Xlim */
  866. X                hdr_length += n_strcpy(&hdr[hdr_length], "\033*b");
  867. X                itoa(countdif,ccount);
  868. X                hdr_length += n_strcpy(&hdr[hdr_length], ccount);
  869. X                hdr_length += n_strcpy(&hdr[hdr_length], "W");
  870. X                write(1, hdr, hdr_length);
  871. X                write(1, mp + r + countsx, countdif);
  872. X            /* end raster graphics */
  873. X                hdr_length = 1 + n_strcpy(&hdr[1], "*rB");
  874. X                write(1, hdr, hdr_length);
  875. X                schrijfspaar=FALSE;
  876. X                fflush(stdout);
  877. X                }
  878. X            }
  879. X         else { /* *p != 0 */
  880. X             if (schrijfspaar==FALSE) {
  881. X                /* make cursorposition header */
  882. X            /* set cursor to current col  */
  883. X                hdr_length = 1 + n_strcpy(&hdr[1], "*p");
  884. X                itoa((countx*8),ccount);
  885. X                hdr_length += n_strcpy(&hdr[hdr_length], ccount);
  886. X                hdr_length += n_strcpy(&hdr[hdr_length], "X");
  887. X            /* set cursor to current row */
  888. X                hdr_length += n_strcpy(&hdr[hdr_length], "\033*p");
  889. X                itoa(county,ccount);
  890. X                hdr_length += n_strcpy(&hdr[hdr_length], ccount);
  891. X                hdr_length += n_strcpy(&hdr[hdr_length], "Y");
  892. X            /* start graphics at current cursor posn */
  893. X                hdr_length += n_strcpy(&hdr[hdr_length], "\033*r1A");
  894. X                countdif=1;countsx=countx;
  895. X                schrijfspaar=TRUE;
  896. X                     }
  897. X                      else /* schrijfspaar==TRUE */
  898. X              {
  899. X                  countdif++;
  900. X              }
  901. X
  902. X             }        /* end of if (*p == 0) */
  903. X                    /* [hot@mh.nl] */
  904. X          }         /* end of if (printer != LASERLOW) */
  905. X        p++;countx++;
  906. X        }             /* end of while (p < maxp) */
  907. X        if (printer == LASERLOW) { 
  908. X            write(1, hdr, hdr_length);
  909. X            write(1, mp + r, Xlim);
  910. X        }
  911. X        else {
  912. X            if (schrijfspaar==TRUE) {
  913. X            /* transfer-line-of-graphics escape sequence -- 235 is Xlim */
  914. X                hdr_length += n_strcpy(&hdr[hdr_length], "\033*b");
  915. X                itoa(countdif,ccount);
  916. X                hdr_length += n_strcpy(&hdr[hdr_length], ccount);
  917. X                hdr_length += n_strcpy(&hdr[hdr_length], "W");
  918. X                write(1, hdr, hdr_length);
  919. X                write(1, mp + r + countsx, countdif);
  920. X            /* end raster graphics */
  921. X                hdr_length = 1 + n_strcpy(&hdr[1], "*rB");
  922. X                write(1, hdr, hdr_length);
  923. X                schrijfspaar=FALSE;
  924. X                }
  925. X        }         /* end else van if (printer==LASERLOW) */
  926. X        fflush(stdout);
  927. X    }        /* end van de grote for loop voor iedere regel */
  928. X    if (printer==LASERLOW) {
  929. X        /* end raster graphics */
  930. X        hdr_length = 1 + n_strcpy(&hdr[1], "*rB");
  931. X        write(1, hdr, hdr_length);
  932. X    }
  933. X
  934. X    /* reset printer and eject the page 
  935. X    hdr_length = 1 + n_strcpy(&hdr[1], "E");
  936. X    write(1, hdr, hdr_length);
  937. X*/
  938. X    /*
  939. X     * set printer to interpret a '\n' char to a '\r\n' pair. this works
  940. X     * in combo with the plot script, which also controls interpretation
  941. X     * of \n's at the port 
  942. X     */
  943. X    hdr_length = 1 + n_strcpy(&hdr[1], "&k2G");
  944. X    write(1, hdr, hdr_length);
  945. X
  946. X    fflush(stdout);
  947. X    }
  948. X}
  949. X
  950. X
  951. X/*
  952. X * copy string from src to dst, including terminating \0.
  953. X * return number of chars copied, excluding terminating \0
  954. X */
  955. Xint
  956. Xn_strcpy(dst, src)
  957. X    char   *dst,
  958. X           *src;
  959. X{
  960. X    char   *p;
  961. X
  962. X    p = src;
  963. X    while (*dst++ = *src++);
  964. X    return ((--src) - p);
  965. X}
  966. X
  967. X
  968. Xlj_init_map()
  969. X{
  970. X    register int k;
  971. X    register char *mp;
  972. X    int     map_max ;
  973. X#ifdef TRUESOLID
  974. X    extern double PUs_per_dot;    /* declared in file filltype.c */
  975. X#endif
  976. X
  977. X    switch(printer) {
  978. X        case LASERLOW:
  979. X            Ylim=1442;
  980. X            Xlim=235;
  981. X            scaleX=0.180859;
  982. X            scaleY=0.180859;
  983. X            rounder=0.0;
  984. X            break;
  985. X        case LASERMED:
  986. X            Ylim=1841;
  987. X            Xlim=300;
  988. X            scaleX=0.231205;
  989. X            scaleY=0.231205;
  990. X            rounder=0.0;
  991. X            break;
  992. X
  993. X/* scaleX = scaleY = number of dots per plotter unit
  994. X                   = 1440 dot rows in y-direction / 7962 PU's in y-dir */
  995. X        case LASERHIGH:
  996. X            Ylim=3000;
  997. X            Ylim8=375;
  998. X            Xlim=298;
  999. X            scaleX=0.2995369;
  1000. X            scaleY=0.2995369;
  1001. X            rounder=0.0;
  1002. X            break;
  1003. X    }
  1004. X    map_max = Ylim * Xlim;
  1005. X
  1006. X#ifdef TRUESOLID
  1007. X    PUs_per_dot = 1.0 / scaleX;    /* used by fix_fill() in file filltype.c */
  1008. X#endif
  1009. X
  1010. X    mp = map;
  1011. X    for (k = 0; k < map_max; k++) {
  1012. X    *mp++ = 0;
  1013. X    }
  1014. X}
  1015. SHAR_EOF
  1016. $TOUCH -am 0216085089 libplot/lp/lj_map.c &&
  1017. chmod 0644 libplot/lp/lj_map.c ||
  1018. echo "restore of libplot/lp/lj_map.c failed"
  1019. set `wc -c libplot/lp/lj_map.c`;Wc_c=$1
  1020. if test "$Wc_c" != "9092"; then
  1021.     echo original size 9092, current size $Wc_c
  1022. fi
  1023. # ============= libplot/lp/maps.c ==============
  1024. echo "x - extracting libplot/lp/maps.c (Text)"
  1025. sed 's/^X//' << 'SHAR_EOF' > libplot/lp/maps.c &&
  1026. X/*
  1027. X * maps.c
  1028. X *
  1029. X * Copyright (c) 1988 Environmental Defense Fund, Inc.
  1030. X *
  1031. X * Uses the value of printer to dispatch map-related function
  1032. X * calls to either ep_map.c or lj_map.c
  1033. X */
  1034. X
  1035. X#include "const.h"
  1036. X#include "vars.h"
  1037. X
  1038. X/*
  1039. X * This is a single bit map, accessed by either the epson or laserjet
  1040. X * map-related function calls, depending on which printer is being used.
  1041. X * It has been declared to be somewhat larger than necessary.
  1042. X */
  1043. X
  1044. Xchar    map[BITMAPSIZE];
  1045. X
  1046. Xinit_map()
  1047. X{
  1048. X    switch (printer) {
  1049. X    case EPSON:
  1050. X    ep_init_map();
  1051. X    break;
  1052. X    case LASERLOW:
  1053. X    case LASERMED:
  1054. X    case LASERHIGH:
  1055. X    lj_init_map();
  1056. X    break;
  1057. X    case IBM_PRO:
  1058. X    ib_init_map();
  1059. X    break;
  1060. X    }
  1061. X}
  1062. X
  1063. Xdump_map(to_printer)
  1064. X    int     to_printer;
  1065. X{
  1066. X    switch (printer) {
  1067. X    case EPSON:
  1068. X    ep_dump_map(to_printer);
  1069. X    break;
  1070. X    case LASERLOW:
  1071. X    case LASERMED:
  1072. X    case LASERHIGH:
  1073. X    lj_dump_map(to_printer);
  1074. X    break;
  1075. X    case IBM_PRO:
  1076. X    ib_dump_map(to_printer);
  1077. X    break;
  1078. X    }
  1079. X}
  1080. X
  1081. Xput_seg(p1, p2)
  1082. X    POINT   p1,
  1083. X            p2;
  1084. X{
  1085. X    switch (printer) {
  1086. X    case EPSON:
  1087. X    ep_put_seg(p1, p2);
  1088. X    break;
  1089. X    case LASERLOW:
  1090. X    case LASERMED:
  1091. X    case LASERHIGH:
  1092. X    lj_put_seg(p1, p2);
  1093. X    break;
  1094. X    case IBM_PRO:
  1095. X    ib_put_seg(p1, p2);
  1096. X    break;
  1097. X    }
  1098. X}
  1099. SHAR_EOF
  1100. $TOUCH -am 1007125888 libplot/lp/maps.c &&
  1101. chmod 0644 libplot/lp/maps.c ||
  1102. echo "restore of libplot/lp/maps.c failed"
  1103. set `wc -c libplot/lp/maps.c`;Wc_c=$1
  1104. if test "$Wc_c" != "1200"; then
  1105.     echo original size 1200, current size $Wc_c
  1106. fi
  1107. echo "End of part 4, continue with part 5"
  1108. exit 0
  1109.  
  1110.  
  1111.  
  1112. -- 
  1113. UUCP: ..!uunet!mcsun!hp4nl!integow!hot    or  hot@integow.UUCP or hot@hot.mug
  1114. Roland van Hout, Sr. software engineer, Integrity software consultants, 
  1115.          Pelmolenlaan 16, 3447 GW Woerden, Netherlands,
  1116.             tel +31 3480-30131, fax +31 3480-30182
  1117.