home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / gle / gle / d_bmp.c < prev    next >
C/C++ Source or Header  |  1992-11-29  |  13KB  |  565 lines
  1. /*--------------------------------------------------------------*/
  2. /*    Bitmap Driver 1.0 (VAX C, TURBO  C) , for GLE V3.0    */
  3. /*--------------------------------------------------------------*/
  4. /* This version writes the PATH to a temporary file which can
  5. /* then be read by a bitmap driver (which has more memory available) */
  6. /*---------------------------------------------------------------------------*/
  7. #include "all.h"
  8. #include <math.h>
  9. #include "core.h"
  10. #include "mygraph.h"
  11. #include "mydev.h"
  12. #ifndef __TURBOC__
  13. #define huge
  14. #else
  15. #include <alloc.h>
  16. #endif
  17. extern int dev_fill,dev_font;
  18. extern int gunit;
  19. extern struct gmodel g;
  20. /*---------------------------------------------------------------------------*/
  21. #define pi 3.141592653
  22. #define false 0
  23. #define true (!false)
  24. #define dbg if ((gle_debug & 64)>0)
  25. extern int gle_debug;
  26. int getch(void);
  27. int kbhit(void);
  28.  
  29.  
  30. int path_newpath(void);
  31. int path_lwidth(float x);
  32. int path_stroke(void);
  33. int path_fill(void);
  34. int path_lstyle(long x);
  35. int path_dashlen(float x);
  36. int path_dline(float x,float y);
  37. int path_size(float x,float y);
  38. int path_row(float x1, float y1, float x2, float y2);
  39. int path_box(float x1, float y1, float x2, float y2);
  40. int dpath_box(double x1, double  y1, double  x2, double y2);
  41. int path_alloc(void);
  42. int path_move(float x1, float y1);
  43. int path_line(float x1, float y1);
  44. int path_closepath(void);
  45. /*---------------------------------------------------------------------------*/
  46. long d_curcolor,d_curfill;
  47. /*---------------------------------------------------------------------------*/
  48. /*   Path variables for bitmap */
  49. typedef union {long l; float f;} longfloat;
  50. longfloat *path;
  51. int npath;
  52. int npath_alloc;
  53.  
  54. #include "dvipath.h"
  55. path_reset()
  56. {
  57. }
  58. path_newpath(void)
  59. {
  60.     path_alloc();
  61.     path[npath++].l = p_newpath;
  62. }
  63. path_move(float x,float y)
  64. {
  65.     path_alloc();
  66.     path[npath++].l = p_move;
  67.     path[npath++].f = x;
  68.     path[npath++].f = y;
  69. }
  70. path_lwidth(float x)
  71. {
  72.     path_alloc();
  73.     path[npath++].l = p_lwidth;
  74.     path[npath++].f = x;
  75. }
  76. path_setcolor(int r, int g, int b, int f)
  77. {
  78.     path_alloc();
  79.     path[npath++].l = p_setcolor;
  80.     path[npath++].l = r;
  81.     path[npath++].l = g;
  82.     path[npath++].l = b;
  83.     path[npath++].l = f;
  84. }
  85. path_stroke(void)
  86. {
  87.     path_alloc();
  88.     path[npath++].l = p_stroke;
  89. }
  90. path_fill(void)
  91. {
  92.     path_alloc();
  93.     path[npath++].l = p_fill;
  94. }
  95. path_int(int x)
  96. {
  97.     path_alloc();
  98.     path[npath++].l = x;
  99. }
  100. path_lstyle(long x)
  101. {
  102.     path_alloc();
  103.     path[npath++].l = p_lstyle;
  104.     path[npath++].l = x;
  105. }
  106. path_dline(float x,float y)
  107. {
  108.     path_alloc();
  109.     path[npath++].l = p_dline;
  110.     path[npath++].f = x;
  111.     path[npath++].f = y;
  112. }
  113. path_size(float x,float y)
  114. {
  115.     path_alloc();
  116.     path[npath++].l = p_size;
  117.     path[npath++].f = x;
  118.     path[npath++].f = y;
  119. }
  120. path_dashlen(float x)
  121. {
  122.     path_alloc();
  123.     path[npath++].l = p_dashlen;
  124.     path[npath++].f = x;
  125. }
  126. path_line(float x,float y)
  127. {
  128.     path_alloc();
  129.     path[npath++].l = p_line;
  130.     path[npath++].f = x;
  131.     path[npath++].f = y;
  132. }
  133. path_bezier(float x1, float y1, float x2, float y2,float x3, float y3)
  134. {
  135.     path_alloc();
  136.     path[npath++].l = p_bezier;
  137.     path[npath++].f = x1;    path[npath++].f = y1;
  138.     path[npath++].f = x2;    path[npath++].f = y2;
  139.     path[npath++].f = x3;    path[npath++].f = y3;
  140. }
  141. path_closepath()
  142. {
  143.     path_alloc();
  144.     path[npath++].l = p_closepath;
  145. }
  146. path_box(float x1, float y1, float x2, float y2)
  147. {
  148.     path_move(x1,y1);
  149.     path_line(x2,y1);
  150.     path_line(x2,y2);
  151.     path_line(x1,y2);
  152.     path_closepath();
  153. }
  154. path_alloc(void)
  155. {
  156.     static int npa;
  157.     long *a;
  158.     if (npath > 100) path_flush();
  159.     if (npath < (npath_alloc-20)) return;
  160.     npath_alloc = 20 + 2 * npath;
  161.     a = myallocz(npath_alloc*sizeof(long));
  162.     if (a==NULL) {
  163.         gle_abort("Unable to allocate memory for path \n");
  164.     }
  165.     if (path != NULL) {
  166.         memcpy(a,path,(npa)*sizeof(long));
  167.         myfree(path);
  168.     }
  169.     npa = npath_alloc;
  170.     path = (longfloat *) a;
  171. }
  172. path_free(void)
  173. {
  174.     if (path==NULL) return;
  175.     myfree(path);
  176.     path = NULL;
  177.     npath = 0;
  178.     npath_alloc = 0;
  179. }
  180.  
  181. d_devcmd(char *s)
  182. {}
  183. dxy(double x, double y, float *dx, float *dy)
  184. {
  185.     static double fx,fy;
  186.     g_dev(x,y,&fx,&fy);
  187.     *dx = fx;
  188.     *dy = fy;
  189. }
  190. rxy(double x, double y, int *dx, int *dy)
  191. {
  192.     static double fx,fy,zx,zy;
  193.     g_dev(x,y,&fx,&fy);
  194.     g_dev(0.0,0.0,&zx,&zy);
  195.     *dx = (int) ( (fx-zx) );
  196.     *dy = (int) ( (fy-zy) );
  197. }
  198. /*---------------------------------------------------------------------------*/
  199. d_dfont(char *c)
  200. {
  201.     /* only used for the DFONT driver which builds fonts (never used)*/
  202. }
  203. /*---------------------------------------------------------------------------*/
  204. d_message(char *s)
  205. {
  206.     printf("%s\n",s);
  207. }
  208. /*---------------------------------------------------------------------------*/
  209. d_source(char *s)
  210. {
  211.     s=s;
  212. }
  213. /*---------------------------------------------------------------------------*/
  214. d_get_type(char *t)
  215. {
  216.     strcpy(t,"OUTPUT, BITMAP, BLACKANDWHITE, HARDCOPY, FILLPATH");
  217. }
  218. /*---------------------------------------------------------------------------*/
  219. d_set_path(int onoff)
  220. {
  221. }
  222. /*---------------------------------------------------------------------------*/
  223. d_newpath()
  224. {
  225.     path_flush();
  226.     path_newpath();
  227. }
  228. /*---------------------------------------------------------------------------*/
  229. FILE *dout;
  230. path_flush(void)
  231. {
  232.     if (npath>0) fwrite(path,sizeof(long),npath,dout);
  233.     npath = 0;
  234. }
  235. d_open(double width, double height)
  236. {
  237.     char *outfile;
  238.     outfile = "out.dvi";
  239.     dout = fopen(outfile,"wb");
  240.     if (dout == NULL) gle_abort("Unable to open OUT.dvi epson output file \n");
  241.     path_alloc();
  242.     path_size(width,height);
  243.     if (!dev_font) plotter_fonts();
  244. }
  245. /*---------------------------------------------------------------------------*/
  246. d_tidyup()
  247. {
  248.     gprint("AARRRrrrrgg,  watch out I'm dying!!!\n");
  249. }
  250. d_close()
  251. {
  252.     g_flush();
  253.     path_flush();
  254.     path_free();
  255.     fclose(dout);
  256. #ifndef unix
  257.     printf("Now enter one of:\n");
  258.     printf("   dviprint -depson [-hires] (to print to a dot matrix printer)\n");
  259.     printf("   dviprint -dlj    [-hires] (to print to HP LaserJet/Deskjet)\n");
  260.     printf("   dviprint -dpj    [-hires] (to print to HP Paintjet)\n");
  261.     printf("   dviprint -dvt             (Preview on screen)\n");
  262.     printf("   dviprint                  (to see other valid qualifiers)\n");
  263. #endif
  264. }
  265. /*---------------------------------------------------------------------------*/
  266. d_set_line_cap(int i)
  267. {
  268.     i++;
  269. }
  270. /*---------------------------------------------------------------------------*/
  271. d_set_line_join(int i)
  272. {
  273.     i++;
  274. }
  275. /*---------------------------------------------------------------------------*/
  276. d_set_line_miterlimit(double d)
  277. {
  278.     int i=0;
  279.     i++;
  280. }
  281. /*---------------------------------------------------------------------------*/
  282. d_set_line_width(double w)
  283. {
  284.     float dx,dy,zx,zy;
  285.  
  286.     dxy(w,w,&dx,&dy);
  287.     dxy(0.0,0.0,&zx,&zy);
  288.     path_lwidth(sqrt(pow(dx-zx,2) + pow(dy-zy,2)));
  289.     path_lwidth(w);
  290. }
  291. /*---------------------------------------------------------------------------*/
  292. d_set_line_styled(double dd)
  293. {
  294.     path_dashlen(dd);
  295. }
  296. d_set_line_style(char *s)
  297. {
  298.     static char *defline[] = {"","","12","41","14","92",
  299.         "1282","9229","4114","54"};
  300.     int i,j,nblack,nwhite;
  301.     char *ss;
  302.     long pat;
  303. /* lstyle pattern output in dvi file is a 32 bit integer:
  304.       First 27 bits (starting with MSB) is the pattern, last 5 bits
  305.       (bits 0 to 4) is one less than the number of the last bit in the pattern.
  306.       This allows continuous patterns (no funny glitches every 32 dots).
  307. */
  308.  
  309.     if (!g.inpath) g_flush();
  310.     if (strlen(s)==1) s = defline[*s-'0'];
  311.     if (strcmp(s,"")==0) {
  312.         pat = 0x8000001e;     /* pattern is one dot repeated */
  313.         path_lstyle(pat);
  314.         return;
  315.     }
  316.     ss = s;
  317.  
  318.         pat = 0;                 /* make up to 27 bit pattern from digits */
  319.     for (i=31; i>4;) {
  320.         nblack = *s - '0';
  321.         s++;
  322.         for (j=0; j<nblack; j++) {
  323.         pat = pat | (1L << i);
  324.         i--;
  325.         }
  326.         if (*s == 0)  s = ss;   /* if odd number of digits, repeat */
  327.         nwhite = *s - '0';
  328.         s++;
  329.         i = i - nwhite;
  330.         if (*s == 0) {          /* stop if at end of digit string */
  331.                 if (i < 4)  i = 4;
  332.                 pat = (pat & 0xffffffe0) | i;
  333.                 break;
  334.             }
  335.     }
  336.     path_lstyle(pat);
  337. /*        printf ("Pattern: %s %X  %d\n", ss, pat, pat&0x1f); */
  338. }
  339. /*---------------------------------------------------------------------------*/
  340. d_fill()
  341. {
  342.     set_fill();
  343.     path_fill();
  344.     set_color();
  345. }
  346. /*---------------------------------------------------------------------------*/
  347. d_fill_ary(int nwk,double (*wkx)[],double (*wky)[])
  348. {
  349.     int i;
  350.  
  351.     path_move( (*wkx)[0], (*wky)[0]);
  352.     for (i=1;i<nwk;i++) {
  353.         path_line( (*wkx)[i], (*wky)[i]);
  354.     }
  355.     d_fill();
  356. }
  357. d_line_ary(int nwk,double (*wkx)[],double (*wky)[])
  358. {
  359.     int i;
  360.  
  361.     path_move( (*wkx)[0], (*wky)[0]);
  362.     for (i=1;i<nwk;i++) {
  363.         path_line( (*wkx)[i], (*wky)[i]);
  364.     }
  365.     d_stroke();
  366. }
  367. /*---------------------------------------------------------------------------*/
  368. d_stroke()
  369. {
  370.     path_stroke();
  371. }
  372. /*---------------------------------------------------------------------------*/
  373. d_clip()
  374. {
  375.     path_int(p_clip);
  376. }
  377. /*---------------------------------------------------------------------------*/
  378. d_set_matrix(double newmat[3][3])
  379. {
  380.  
  381. }
  382. /*---------------------------------------------------------------------------*/
  383. d_move(double zx,double zy)
  384. {
  385. }
  386. /*---------------------------------------------------------------------------*/
  387. d_reverse()     /* reverse the order of stuff in the current path */
  388. {
  389. }
  390. /*---------------------------------------------------------------------------*/
  391. d_closepath()
  392. {
  393.     path_closepath();
  394. }
  395. int bit_line( double x, double y);
  396. /*---------------------------------------------------------------------------*/
  397. d_line(double zx,double zy)
  398. {
  399.     float dx,dy;
  400.     if (g.xinline==false) {
  401.         dxy(g.curx,g.cury,&dx,&dy);
  402.         path_move(dx,dy);
  403.     }
  404.     if (g.inpath==false) {
  405.         dxy(zx,zy,&dx,&dy);
  406.         path_dline(dx,dy);
  407.         return;
  408.     }
  409.     dxy(zx,zy,&dx,&dy);
  410.     path_line(dx,dy);
  411. }
  412. /*---------------------------------------------------------------------------*/
  413. d_clear()
  414. {
  415. }
  416. /*---------------------------------------------------------------------------*/
  417. d_flush()
  418. {
  419. }
  420. /*---------------------------------------------------------------------------*/
  421. d_arcto(dbl x1,dbl y1,dbl x2,dbl y2,dbl rrr)
  422. {
  423.     df_arcto(x1,y1,x2,y2,rrr);
  424. }
  425. /*---------------------------------------------------------------------------*/
  426. d_arc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  427. {
  428.     df_arc(r,t1,t2,cx,cy);
  429. }
  430. /*---------------------------------------------------------------------------*/
  431. d_narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  432. {
  433.     df_arc(r,t1,t2,cx,cy);
  434. }
  435. /*---------------------------------------------------------------------------*/
  436. d_box_fill(dbl x1, dbl y1, dbl x2, dbl y2)
  437. {
  438.     set_fill();
  439.     if (g.inpath==true) dpath_box(x1,y1,x2,y2);
  440.     else {
  441.         g_flush();
  442.         d_newpath();
  443.         dpath_box(x1,y1,x2,y2);
  444.         d_fill();
  445.     }
  446.     set_color();
  447. }
  448. d_box_stroke(dbl x1, dbl y1, dbl x2, dbl y2)
  449. {
  450.     if (g.inpath==true) df_box_stroke(x1,y1,x2,y2);
  451.     else {
  452.         g_flush();
  453.         d_newpath();
  454.         df_box_stroke(x1,y1,x2,y2);
  455.         d_stroke();
  456.     }
  457. }
  458. /*---------------------------------------------------------------------------*/
  459. d_circle_stroke(double zr)
  460. {
  461.     double xx,yy;
  462.     g_get_xy(&xx,&yy);
  463.     df_circle_stroke(zr);
  464.     g_move(xx,yy);
  465. }
  466. d_circle_fill(double zr)
  467. {
  468.     int savep;
  469.     double xx,yy;
  470.     g_get_xy(&xx,&yy);
  471.     savep = g.inpath;
  472.     g.inpath = true;
  473.     set_fill();
  474.     df_circle_fill(zr);
  475.     d_fill();
  476.     set_color();
  477.     g.inpath = savep;
  478.     g_move(xx,yy);
  479. }
  480. /*---------------------------------------------------------------------------*/
  481. int df_bezier(dbl x1,dbl y1,dbl x2,dbl y2,dbl x3,dbl y3);
  482. d_bezier(dbl x1,dbl y1,dbl x2,dbl y2,dbl x3,dbl y3)
  483. {
  484.     float dx1,dy1,dx2,dy2,dx3,dy3,dx0,dy0;
  485.  
  486.     if (g.xinline==false) {
  487.         dxy(g.curx,g.cury,&dx0,&dy0);
  488.         path_move(dx0,dy0);
  489.     }
  490.  
  491.     dxy(x1,y1,&dx1,&dy1);
  492.     dxy(x2,y2,&dx2,&dy2);
  493.     dxy(x3,y3,&dx3,&dy3);
  494.     path_bezier(dx1,dy1,dx2,dy2,dx3,dy3);
  495.     if (g.inpath != true) path_stroke();
  496. }
  497. dpath_box(dbl x1,dbl y1,dbl x2,dbl y2)
  498. {
  499.     float dx1,dy1,dx2,dy2,dx3,dy3,dx4,dy4;
  500.  
  501.     dxy(x1,y1,&dx1,&dy1);
  502.     dxy(x2,y1,&dx2,&dy2);
  503.     dxy(x2,y2,&dx3,&dy3);
  504.     dxy(x1,y2,&dx4,&dy4);
  505.  
  506.     path_move(dx1,dy1);
  507.     path_line(dx2,dy2);
  508.     path_line(dx3,dy3);
  509.     path_line(dx4,dy4);
  510.     path_closepath();
  511. }
  512. /*---------------------------------------------------------------------------*/
  513. set_color()
  514. {
  515.     colortyp cc;
  516.     cc.l = d_curcolor;
  517.     path_setcolor(cc.b[B_R],cc.b[B_G],cc.b[B_B],cc.b[B_F]);
  518. }
  519. set_fill()
  520. {
  521.     colortyp cc;
  522.     cc.l = d_curfill;
  523.     path_setcolor(cc.b[B_R],cc.b[B_G],cc.b[B_B],cc.b[B_F]);
  524. }
  525. d_set_color(long f)
  526. {
  527.     d_curcolor = f;
  528.     set_color();
  529. }
  530. d_set_fill(long f)
  531. {
  532.     d_curfill = f;
  533. }
  534. /*---------------------------------------------------------------------------*/
  535. d_beginclip()
  536. {
  537.     path_int(p_saveclip);
  538. }
  539. d_endclip()
  540. {
  541.     path_int(p_restoreclip);
  542. }
  543. struct char_data {float wx,wy,x1,y1,x2,y2; };
  544. int font_get_chardata(struct char_data **cd, int ff, int cc);
  545. /*---------------------------------------------------------------------------*/
  546. int safnt;
  547. int simple_char(int cc);
  548. d_char(int font, int cc)
  549. {
  550.     static struct char_data cd;
  551.     static int ix1,ix2,iy1,iy2;
  552.     static int ux,uy;
  553.     char ss[2];
  554.  
  555.     ss[0] = cc;
  556.     ss[1] = 0;
  557.     if (safnt==0) safnt = pass_font("PLSR");
  558.     if (font_get_encoding(font)>2) {
  559.         my_char(font,cc);
  560.         return;
  561.     }
  562.     my_char(safnt,cc);
  563. }
  564.  
  565.