home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / pstoedit.zip / source.zip / pstoedit.2.50 / cd1.2x / cd.c < prev    next >
C/C++ Source or Header  |  1996-11-22  |  65KB  |  2,317 lines
  1.  
  2. /* cd.c main file for cgmdraw module.
  3.  
  4.         Written by G. Edward Johnson <mailto:lorax@nist.gov>
  5.         Date: April 1996
  6.         Copyright: cd software produced by NIST, an agency of the 
  7.     U.S. government, is by statute not subject to copyright
  8.     in the United States. Recipients of this software assume all 
  9.     responsibilities associated with its operation, modification
  10.     and maintenance.
  11.  
  12.         Portions of this package are from the gd package written by
  13.     Thomas Boutell and are copyright 1994, 1995, Quest Protein 
  14.     Database Center, Cold Spring Harbor Labs.  They are marked in the
  15.     source code.
  16.  
  17. */
  18.  
  19.  
  20. #include <malloc.h>
  21. #include <stdio.h>
  22. #include <math.h>
  23. #include <string.h>
  24. #include <stdlib.h>
  25. #include "defines.h"
  26. #include "cd.h"
  27.  
  28. static    const unsigned char * fontnames [] = {
  29.     (unsigned char *) "Times",
  30.     (unsigned char *) "Times Bold",
  31.     (unsigned char *) "Times Italic",
  32.     (unsigned char *) "Times Bold Italic",
  33.     (unsigned char *) "Helvetica",
  34.     (unsigned char *) "Helvetica Bold",
  35.     (unsigned char *) "Helvetica Italic",
  36.     (unsigned char *) "Helvetica Bold Italic",
  37.     (unsigned char *) "Courier",
  38.     (unsigned char *) "Courier Bold",
  39.     (unsigned char *) "Courier Italic",
  40.     (unsigned char *) "Courier Bold Italic",
  41.     (unsigned char *) "Symbol",
  42.     0 
  43. };
  44.  
  45. static const int numberOfFonts = (sizeof(fontnames) / sizeof(unsigned char *) ) - 1;
  46.  
  47. cdImagePtr cdImageCreate(int sx, int sy)
  48. {
  49.     cdImagePtr im;
  50. /*    fprintf(stderr,"number of Fonts %d\n",numberOfFonts); */
  51.     im = (cdImage *) calloc(SIZEOF(cdImage), 1);
  52.     if (!im) return 0; /* memory allocation failed */
  53.     /* elemlist is set to some number, when it is full, make it bigger */
  54.     im->elemlist = (unsigned char *) calloc(CDSTARTLISTSIZE, SIZEOF(unsigned char ) );
  55.     if (!im->elemlist) return 0; /* memory allocation failed */
  56.     im->sx = sx;
  57.     im->sy = sy;
  58.     im->colorsTotal = 0;
  59.     /* you can have multiple pictures in a file,  keep track of
  60.      * which one you are on */
  61.     im->picnum = 10;
  62.     /* set line_width, line_height, line_color to the defaults */
  63.     /*gej: I should change these when I figure out what the defaults are */
  64.     im->ltype = CDLTYPE;
  65.     im->lwidth = CDLWIDTH;
  66.     im->lcolor = CDLCOLOR;
  67.     /* interior_style, fill_color, hatch_index */
  68.     im->shapestyle = CDSHAPESTYLE;
  69.     im->shapecolor = CDSHAPECOLOR;
  70.     im->shapehatch = CDSHAPEHATCH;
  71.     /* edge_type, edge_width, edge_color, edge_visibility */
  72.     im->edgetype = CDEDGETYPE;
  73.     im->edgecolor = CDEDGECOLOR;
  74.     im->edgewidth = CDEDGEWIDTH;
  75.     im->edgevis = CDEDGEVIS;
  76.     /* text_color, text_height, text_font */
  77.     im->textcolor = CDTEXTCOLOR;
  78.     im->textheight = CDTEXTHEIGHT;
  79.     im->textfont = CDTEXTFONT;
  80.     im->textpath = CDTEXTPATH;
  81.     /* the next three are used for maintaining the element list
  82.      * don't change these ever */
  83.     im->bytestoend = CDSTARTLISTSIZE;
  84.     im->listlen = CDSTARTLISTSIZE;
  85.     im->curelemlist = im->elemlist;
  86.  
  87.     cdCgmHeader(im);
  88.     return im;
  89.        
  90. }
  91.  
  92. static int cdAppNull(unsigned char *es, int x) {
  93. /* put x  nulls in the string.
  94.  * return value is number of octets added (1) */
  95.     int y;
  96.  
  97.     for(y=0; y<x; y++) {
  98.         *es = '\0';
  99.         es++;
  100.     }
  101.     return x;
  102.  
  103. }
  104.  
  105. static int cdAppByte(unsigned char *es, short int addme) {
  106. /* Append an octet to the end of es 
  107.  * Return value is number of octets added
  108.  * for internal cd functions only, do not call
  109.  */
  110.     *es = addme & 0377;
  111.     return 1;
  112. }
  113.  
  114. static int cdAppShort(unsigned char *es, short int addme) {
  115. /* Append a short to the end of es 
  116.  * return value is number of octets added
  117.  * For internal cd functions only, do not call!
  118.  */
  119.     short int temp;
  120.  
  121.     temp = addme >> 8;
  122.     *es = (unsigned char) temp & 0377;
  123.     es++;
  124.     *es = (unsigned char) addme & 0377;
  125.     return 2;
  126. }
  127.  
  128. /* static int cdAppWord(unsigned char *es, int addme){ */
  129. /* Append an word to es 
  130.  * Return value is number of octets added
  131.  * For internal cd functions only, do not call!
  132.  */
  133. /*
  134.     int temp;
  135.     temp = addme >> 24;
  136.     *es = (unsigned char) temp & 0377;
  137.     es++;
  138.     temp = addme >> 16;
  139.     *es = (unsigned char) temp & 0377;
  140.     es++;
  141.     temp = addme >> 8;
  142.     *es = (unsigned char) temp & 0377;
  143.     es++;
  144.     *es = (unsigned char) addme & 0377;
  145.     es++;
  146.     return 4;
  147. }
  148. */
  149.  
  150. static int cdcomhead(unsigned char *es, int elemclass, int id, int len) {
  151. /* sets the command header in the first two bytes of string es 
  152.  * element class is in bits 15-12
  153.  * element id is in bits 11-5
  154.  * parameter list length is in bits 4-0
  155.  */
  156.     int temp;
  157.  
  158.     if (!es) return 0; /* the string must be allocated first */
  159.  
  160.     /* set the element class */
  161.     *es = (unsigned char) elemclass << 4;
  162.     /* set the element id */
  163.     temp = 0177 & id ;
  164.     temp = temp >> 3;
  165.     *es = *es | temp;
  166.     es++;
  167.     id = id << 5;
  168.     *es = (unsigned char) id;
  169.     *es = *es | (unsigned char) ( 037 & len );
  170.  
  171.     return 1;
  172. }
  173.  
  174. static int cdcomheadlong(unsigned char *es, int elemclass, int id, int len) {
  175. /* sets the command header for the long form.
  176.  * first 16 bits:
  177.  *  element class is in bits 15-12
  178.  *  element id is in bits 11-5
  179.  *  parameter list length is in bits 4-0 = 31
  180.  * second 16 bits:
  181.  *  bit 15 = 0  (for last partition)
  182.  *  bit 14-0 param list len
  183.  */
  184.  
  185.     /* I'm lazy, call cdcomhead to set the first two bytes */
  186.     if (!cdcomhead(es, elemclass, id, 31)) return 0;
  187.     es += 2;
  188.  
  189.     /* now set the second two bytes */
  190.     cdAppShort(es, (short int) len);
  191.     *es = *es & 0177; /* make bit 15 = 0 */
  192.     es += 2;
  193.  
  194.     return 1;
  195. }
  196.  
  197. static int cdAddElem(cdImagePtr im, unsigned char *es, int octet_count)
  198. /* adds a string, which is a CGM element to the elemlist.
  199.  * This function is called by other functions in this library and
  200.  * should NOT be called by users of the library
  201.  * For internal cd functions only, do not call!
  202.  */
  203. {
  204.     unsigned char *newlist; /* in case memory allocation fails */
  205.     int x; /* counter */
  206.  
  207.     while ((octet_count + 1) >= im->bytestoend) {
  208.     /* not enough space, must grow elemlist */
  209.         im->listlen = im->listlen + CDGROWLISTSIZE;
  210.         newlist = (unsigned char *) realloc(im->elemlist, SIZEOF(unsigned char ) * im->listlen);
  211.         if (newlist) {
  212.         /* successfully allocated memory */
  213.             im->elemlist = newlist;
  214.             im->bytestoend = im->bytestoend + CDGROWLISTSIZE;
  215.             im->curelemlist = im->elemlist + (im->listlen - im->bytestoend);
  216.         }
  217.         else {
  218.         /* memory allocation failed, save yurself */
  219.             im->listlen = im->listlen - CDGROWLISTSIZE;
  220.             return 0;
  221.         }
  222.     }
  223.  
  224.     /* ok, if we get to here, there is enough space, so add it. */
  225.     for (x=0; x < octet_count; x++) {
  226.         *im->curelemlist = (unsigned char) *es;
  227.         im->curelemlist++;
  228.         es++;
  229.     }
  230.     im->bytestoend = im->bytestoend - octet_count;
  231.     return 1;
  232.  
  233. }
  234.  
  235. int cdCgmHeader(cdImagePtr im) {
  236. /* add the cgm header to the imagepointer's  element list
  237.  * do it all in a string than call cdAddElem on it
  238.  * For internal cd functions only, do not call!
  239.  */
  240.     unsigned char *headerp;
  241.     unsigned char *head;
  242.     unsigned char *buf, *buf2;
  243.     int octet_count=0;
  244.     int blen; /* length of buf */
  245.     int curly;
  246.  
  247.     headerp = (unsigned char *) calloc(1024, SIZEOF(unsigned char ));
  248.         if (!headerp) return 0; /* memory allocation failed */
  249.     head=headerp;
  250.  
  251.     /*** Attribute: BegMF; Elem Class 0; Elem ID 1 */
  252.     buf = (unsigned char *) "cd: CgmDraw Library";
  253.     blen = strlen( (char *) buf);
  254.     cdcomhead(head, 0, 1, blen+1);
  255.     head += 2;
  256.     head += cdAppByte(head, (short int) blen); 
  257.     buf2 = buf;
  258.     while (*buf2) {
  259.         *head++ = *buf2++;
  260.     }
  261.     octet_count += (blen + 3);
  262.     curly = 4 - (octet_count % 4);
  263.     if (curly % 4) {
  264.         octet_count += curly;
  265.         head += cdAppNull(head, curly);
  266.     }
  267.  
  268.     /*** Attribute: MFVersion; Elem Class 1; Elem ID 1 */
  269.     cdcomhead(head, 1, 1, 2);
  270.     head += 2;
  271.     head += cdAppShort(head, (short int) 1);
  272.     octet_count += 4;
  273.  
  274.     /*** Attribute: MFDesc; Elem Class 1; Elem ID 2 */
  275.     buf = (unsigned char *) "'ProfileId: Model-Profile''ProfileEd:1''ColourClass:colour''Source:Nist CGMDraw 1.2''Date: 1996-06-28'";
  276.     blen = strlen( (char *) buf);
  277.     cdcomheadlong(head, 1, 2, blen+1);
  278.     head += 4;
  279.     head += cdAppByte(head, (short int) blen); 
  280.     buf2 = buf;
  281.     while (*buf2) {
  282.         *head++ = *buf2++;
  283.     }
  284.     octet_count += (blen + 5);
  285.     curly = 4 - (octet_count % 4);
  286.     if (curly % 4) {
  287.         octet_count += curly;
  288.         head += cdAppNull(head, curly);
  289.     }
  290.  
  291.     /*** Attribute: ColrPrec; Elem Class 1; Elem ID 7 */
  292.     cdcomhead(head, 1, 7, 2);
  293.     head += 2;
  294.     head += cdAppShort(head, (short int) 8);
  295.     octet_count += 4;
  296.  
  297.     /*** Attribute: ColrIndexPrec; Elem Class 1; Elem ID 8 */
  298.     cdcomhead(head, 1, 8, 2);
  299.     head += 2;
  300.     head += cdAppShort(head, (short int) 8);
  301.     octet_count += 4;
  302.  
  303.     /*** Attribute: MaxColrIndex; Elem Class 1; Elem ID 9 */
  304.     cdcomhead(head, 1, 9, 1);
  305.     head += 2;
  306.     head += cdAppByte(head, (short int) 255);
  307.     octet_count += 4; head++;
  308.  
  309.     /*** Attribute: MFElemList; Elem Class 1; Elem ID 11 */
  310.     /* shorthand here.  1 means 1 element specified, (-1,1)
  311.      * means drawing-plus-control set */
  312.     cdcomhead(head, 1, 11, 6);
  313.     head += 2;
  314.     head += cdAppShort(head, (short int) 1);
  315.     head += cdAppShort(head, (short int) -1);
  316.     head += cdAppShort(head, (short int) 1);
  317.     octet_count += 8;
  318.  
  319.     /*** Attribute: FontList; Elem Class 1; Elem ID 13 */
  320.     /* get string length of all font names together */
  321.     {
  322.     int len = 0;
  323.     const unsigned char * * font = fontnames;
  324.     while (*font) {
  325. /*        fprintf(stderr,"length of '%s' %d\n",*font,strlen((char *) *font)); */
  326.         len += strlen((char *) *font) + 1; /* add one for end */
  327.         font++;
  328.     }
  329. /*    fprintf(stderr,"length of all fontnames %d\n",len); */
  330.     cdcomheadlong(head, 1, 13, len);
  331.     }
  332.     head +=4;
  333.  
  334.     {
  335.     const unsigned char * * font = fontnames;
  336.     while (*font) {
  337.         buf = (unsigned char *) *font;
  338.         blen = strlen( (char *) buf);
  339. /*         fprintf(stderr,"length of %s %d\n",buf,blen); */
  340.         head += cdAppByte(head, (short int) blen);
  341.         buf2 = buf;
  342.         while (*buf2) {
  343.             *head++ = *buf2++;
  344.         }
  345.         octet_count += blen + 1;
  346.         font++;
  347.     }
  348.     }
  349.  
  350.     octet_count += 4 ;
  351.  
  352.     curly = 4 - (octet_count % 4);
  353.     if (curly % 4) {
  354.         octet_count += curly;
  355.         head += cdAppNull(head, curly);
  356.     }
  357.  
  358.  
  359.     if (cdAddElem(im, headerp, octet_count)) {
  360.         free(headerp);
  361.         headerp = 0;
  362.     }
  363.     else {
  364.         free(headerp);
  365.         return 0;
  366.     }
  367.  
  368.     if (cdCgmPic(im, 0)) {
  369.         return 1;
  370.     }
  371.     else {
  372.         return 0;
  373.     }
  374. }
  375.  
  376.  
  377. int cdCgmPic(cdImagePtr im, int sticky) {
  378. /* Start the picture.  if the sticky bit is set, set and use the defaults
  379.  * of the previous picture.  Otherwise, reset all defaults.
  380.  * Gej:  Right now, will only work if the sticky bit is not set (is 0)
  381.  */
  382.  
  383.     int absolute = 1;
  384.  /* if absolute is true, then "Line/Edge Width Specification Mode" is set to absolute */
  385.     unsigned char *headerp;
  386.     unsigned char *head;
  387.     unsigned char *buf, *buf2;
  388.     char *tb;
  389.     int octet_count=0;
  390.     int blen; /* length of buf */
  391.  
  392.     /* increment the picture number */
  393.     im->picnum++;
  394.     tb = (char *) calloc(4*4, SIZEOF(char) );
  395.     headerp = (unsigned char *) calloc(1024, SIZEOF(unsigned char ));
  396.         if (!headerp) return 0; /* memory allocation failed */
  397.     head=headerp;
  398.  
  399.  
  400.     /*** Attribute: BegPic; Elem Class 0; Elem ID 3 */
  401.     sprintf(tb, "picture %d", im->picnum);
  402.     buf = (unsigned char*) tb;
  403.     /* buf = (unsigned char *) "picture 1"; */
  404.     blen = strlen( (char *) buf);
  405.     cdcomhead(head, 0, 3, blen+1);
  406.     head += 2;
  407.     head += cdAppByte(head, (short int) blen); 
  408.     buf2 = buf;
  409.     while (*buf2) {
  410.         *head++ = *buf2++;
  411.     }
  412.  
  413.     free(tb);
  414.  
  415.     octet_count += (blen + 3);
  416.     if (!(blen % 2)) {
  417.         octet_count++;
  418.         head += cdAppNull(head, 1);
  419.     }
  420.     if (octet_count % 4) {
  421.         octet_count +=2;
  422.         head += cdAppNull(head, 2);
  423.     }
  424.  
  425.     if (absolute) {
  426.         /*** Attribute: Line Width Spec Mode; Elem Class 2; Elem ID 3 */
  427.         cdcomhead(head, 2, 3, 2);
  428.         head += 2;
  429.         head += cdAppShort(head, (short int) 0);
  430.         octet_count += 4;
  431.  
  432.         /*** Attribute: Edge Width Spec Mode; Elem Class 2; Elem ID 5 */
  433.         cdcomhead(head, 2, 5, 2);
  434.         head += 2;
  435.         head += cdAppShort(head, (short int) 0);
  436.         octet_count += 4;
  437.     }
  438.  
  439.     /*** Attribute: ColrMode; Elem Class 2; Elem ID 2 */
  440.     cdcomhead(head, 2, 2, 2);
  441.     head += 2;
  442.     head += cdAppShort(head, (short int) 0);
  443.     octet_count += 4;
  444.  
  445.     /*** Attribute: VDCExt; Elem Class 2; Elem ID 6 */
  446.     cdcomhead(head, 2, 6, 8);
  447.     head += 2;
  448.     head += cdAppShort(head, (short int) 0);
  449.     head += cdAppShort(head, (short int) 0);
  450.     head += cdAppShort(head, (short int) im->sx);
  451.     head += cdAppShort(head, (short int) im->sy);
  452.     octet_count += 10;
  453.  
  454.     /*** Attribute: ColrPrec; Elem Class 0; Elem ID 4 */
  455.     cdcomhead(head, 0, 4, 0);
  456.     head += 2;
  457.     octet_count += 2;
  458.  
  459.     if (sticky) {
  460.     /* gej: were screwed. This isn't implemented yet */
  461.         free(headerp);
  462.         return 0;
  463.     }
  464.     else {
  465.     /* reset all the defaults */
  466.         /* set line_width, line_height, line_color to the defaults */
  467.         im->ltype = CDLTYPE;
  468.         im->lwidth = CDLWIDTH;
  469.         im->lcolor = CDLCOLOR;
  470.         /* interior_style, fill_color, hatch_index */
  471.         im->shapestyle = CDSHAPESTYLE;
  472.         im->shapecolor = CDSHAPECOLOR;
  473.         im->shapehatch = CDSHAPEHATCH;
  474.         /* edge_type, edge_width, edge_color, edge_visibility */
  475.         im->edgetype = CDEDGETYPE;
  476.         im->edgecolor = CDEDGECOLOR;
  477.         im->edgewidth = CDEDGEWIDTH;
  478.         im->edgevis = CDEDGEVIS;
  479.         /* text_color, text_height, text_font */
  480.         im->textcolor = CDTEXTCOLOR;
  481.         im->textheight = CDTEXTHEIGHT;
  482.         im->textfont = CDTEXTFONT;
  483.         im->textpath = CDTEXTPATH;
  484.         /* Nuke the color table if there is one */
  485.         cdImageColorClear(im);
  486.     }
  487.  
  488.  
  489.     if (cdAddElem(im, headerp, octet_count)) {
  490.         free(headerp);
  491.         return 1;
  492.     }
  493.     else {
  494.         free(headerp);
  495.         return 0;
  496.     }
  497.  
  498. } 
  499.  
  500. int cdCgmNewPic(cdImagePtr im, int sticky)
  501. /* The CGM standard allows multiple images in a single file.  This function
  502.  * will close the current picture, then open a new one.
  503.  * if sticky is 0 then all attributes will be reset to the defaults
  504.  * if sticky is 1 then all attributes will be inherited from the prevous
  505.  * picture.  This is currently not implemented, be sure to set sticky to
  506.  * 0.
  507.  */
  508. {
  509.     unsigned char *es, *esp;
  510.     int octet_count=0;
  511.  
  512.     esp = (unsigned char *) calloc(1024, SIZEOF(unsigned char ));
  513.         if (!esp) return 0; /* memory allocation failed */
  514.     es=esp;
  515.  
  516.     /* Attribute: End Picture; Elem Class 0; Elem ID 5; Length 0  */
  517.     cdcomhead(es, 0, 5, 0);
  518.     octet_count += 2;
  519.  
  520.  
  521.     if (cdAddElem(im, esp, octet_count)) {
  522.         free(esp);
  523.     }
  524.     else {
  525.         free(esp);
  526.         return 0;
  527.     }
  528.  
  529.     /* now start the new picture */
  530.     return(cdCgmPic(im, sticky));
  531.  
  532.  
  533. }
  534.  
  535. int cdImageCgm(cdImagePtr im, FILE *out)
  536. /* Gej: Write the image to  file *out, which must be open already
  537.  * does not close the file */
  538. {
  539.     int x; /* counter */
  540.     int used; /* number of bytes used in the list */
  541.     unsigned char *efile, *efilep; /* end of file information */
  542.      efile = (unsigned char *) calloc(4*4,SIZEOF(unsigned char ));
  543.         if (!efile) return 0; /* memory allocation failed */
  544.         efilep=efile;
  545.     /* Attribute: End Picture; Elem Class 0; Elem ID 5 */
  546.     *efilep = '\0';
  547.     efilep++;
  548.     *efilep = '\240'; /* set Elem ID */
  549.     efilep++;
  550.     /* Attribute: End Metafile; Elem Class 0; Elem ID 2 */
  551.     *efilep = '\0';
  552.     efilep++;
  553.     *efilep = '\100'; /* set Elem ID */
  554.  
  555.  
  556.         if (cdAddElem(im, efile, 4)) {
  557.                 free(efile);
  558.         efile = 0;
  559.         efilep = 0;
  560.         }
  561.         else {
  562.                 free(efile);
  563.                 return 0;
  564.         }
  565.  
  566.     /* now output the string, one byte at a time */
  567.     used = im->listlen - im->bytestoend;
  568.     for (x=0;x < used; x++) {
  569.         putc((unsigned char) im->elemlist[x], out);
  570.     }
  571.  
  572.     return 1;
  573.  
  574. }
  575.  
  576.  
  577. int cdSetLineType(cdImagePtr im, int lntype) {
  578. /* Attribute: Line Type; Elem Class 5; Elem ID 2
  579.  * Set the line type.  Possible values are:
  580.  * 1=solid, 2=dash, 3=dot, 4=dash-dot, 5=dash-dot-dot
  581.  * Even though new ones can be defined, I am limiting lntype to these values
  582.  * If you really need more, you can make the proper changes.
  583.  */
  584.     unsigned char *es, *esp;
  585.     int octet_count;
  586.  
  587.     /* First check and see if the user doesn't want any changes,
  588.      * if so, just return success */
  589.     if (lntype == -1)
  590.         return 1;
  591.  
  592.     /* Check and see if the value it is being set to is the current
  593.      * value, if so, don't make any changes, just return 1 */
  594.     if (lntype == im->ltype)
  595.         return 1;
  596.  
  597.     /* Make sure that lntype is between 1 and 5 */
  598.     if ((lntype < 1) || (lntype > 5))
  599.         return 0;
  600.  
  601.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  602.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  603.     if (!es) return 0; /* memory allocation failed */
  604.     esp=es;
  605.  
  606.     if (!cdcomhead(es, 5, 2, 2)) return 0;
  607.     es += 2;
  608.     /* set Param_List_Len to 2 (signed int at index precision) */
  609.  
  610.     /* add in the value of lntype */
  611.     es += cdAppShort(es, (short int) lntype);
  612.  
  613.     octet_count = 4; /* we just know this */
  614.  
  615.     /* add it to the buffer */
  616.     if (cdAddElem(im, esp, octet_count)) {
  617.         im->ltype = (short int) lntype;
  618.         free(esp);
  619.         return 1;
  620.     }
  621.     else {
  622.         free(esp);
  623.         return 0;
  624.     }
  625.  
  626. }
  627.  
  628. int cdSetLineWidth(cdImagePtr im, int lnwidth) {
  629. /* Attribute: Line Width; Elem Class 5; Elem ID 3
  630.  * sets the line width.  with an image of height X with line width 1
  631.  * the displayed width will be 1/X%.  as an example, if you image is
  632.  * x=5, y=10, and you set line width = 1, and draw a vertical line, the
  633.  * resulting line will  cover 20% of horizontal area.
  634.  */
  635.     unsigned char *es, *esp;
  636.     int octet_count;
  637.  
  638.     /* First check and see if the user doesn't want any changes,
  639.      * if so, just return success */
  640.     if (lnwidth == -1)
  641.         return 1;
  642.  
  643.     /* Check and see if the value it is being set to is the current
  644.      * value, if so, don't make any changes, just return 1 */
  645.     if (lnwidth == im->lwidth)
  646.         return 1;
  647.  
  648.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  649.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  650.     if (!es) return 0; /* memory allocation failed */
  651.     esp=es;
  652.  
  653.  
  654.     octet_count = 2;
  655.     if (!cdcomhead(es, 5, 3, 4)) return 0;
  656.     es += 2;
  657.     /*gej: line width is 32 bit floating point number, 16 bits before the
  658.      * decimal, 16 bits after.   */
  659.  
  660.     es += cdAppShort(es, (short int) lnwidth);
  661.  
  662.     /* the next two (after decimal point) will always be zero */
  663.     es += cdAppNull(es, 2);
  664.  
  665.     octet_count += 4;
  666.     
  667.     
  668.     /* add it to the buffer */
  669.     if (cdAddElem(im, esp, octet_count)) {
  670.         im->lwidth = lnwidth;
  671.         free(esp);
  672.         return 1;
  673.     }
  674.     else {
  675.         free(esp);
  676.         return 0;
  677.     }
  678.  
  679.  
  680. }
  681.  
  682. int cdSetLineColor(cdImagePtr im, int lncolor) {
  683. /* Attribute: Line Colour; Elem Class 5; Elem ID 4
  684.  * Sets the line color.  lncolor should be an index into the color
  685.  * table that you have previously allocated.
  686.  */
  687.     unsigned char *es, *esp;
  688.     int octet_count;
  689.     /* First check and see if the user doesn't want any changes,
  690.      * if so, just return success */
  691.     if (lncolor == -1)
  692.         return 1;
  693.  
  694.     /* Check and see if the value it is being set to is the current
  695.      * value, if so, don't make any changes, just return 1 */
  696.     if (lncolor == im->lcolor)
  697.         return 1;
  698.  
  699.     /* Make sure the color they want to use has been allocated. 
  700.      * also, that color must be non-negative */
  701.     if ((lncolor >= im->colorsTotal ) || (lncolor < 0))
  702.         return 0;  /* you must allocate a color before you use it */
  703.  
  704.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  705.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  706.     if (!es) return 0; /* memory allocation failed */
  707.     esp=es;
  708.  
  709.  
  710.     if (!cdcomhead(es, 5, 4, 1)) return 0;
  711.     es += 2;
  712.  
  713.     *es =  0377 & lncolor; /* mask off last 8 bits and put in es */
  714.     es++;
  715.  
  716.     es += cdAppNull(es, 1);
  717.  
  718.     octet_count = 4; /* we just know this; 2 octets of header,
  719.                       * 1 octet of data, 1 octet of null data */
  720.  
  721.         /* add it to the buffer */
  722.         if (cdAddElem(im, esp, octet_count)) {
  723.         im->lcolor = (short int) lncolor;
  724.                 free(esp);
  725.                 return 1;
  726.         }
  727.         else {
  728.                 free(esp);
  729.                 return 0;
  730.         }
  731.  
  732.  
  733. }
  734.  
  735. int cdSetFillStyle(cdImagePtr im, int instyle) {
  736. /* set the style of the interior of filled area elements.
  737.  * Attribute: Interior Style; Elem Class 5; Elem ID 22
  738.  * These attributes stay in effect until changed, so you don't have to output
  739.  * them every time.
  740.  *     Interior Style: (integers 0-6, corresponding to: hollow, solid,
  741.  *                      [not pattern], hatch, empty, [not geometric pattern],
  742.  *                      interpolated.)
  743.  * attribute is 16 bit signed int
  744.  */
  745.     unsigned char *es, *esp;
  746.     int octet_count;
  747.  
  748.     /* First check and see if the user doesn't want any changes,
  749.      * if so, just return success */
  750.     if (instyle == -1)
  751.         return 1;
  752.  
  753.     /* Check and see if the value it is being set to is the current
  754.      * value, if so, don't make any changes, just return 1 */
  755.     if (instyle == im->shapestyle)
  756.         return 1;
  757.  
  758.     /* Make sure that lnhatch is between 0 and 6, but not
  759.      * 2, 5, or 6 */
  760.     if ((instyle < 0) || (instyle > 4) || (instyle == 2))
  761.         return 0;
  762.  
  763.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  764.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  765.     if (!es) return 0; /* memory allocation failed */
  766.     esp=es;
  767.  
  768.     /* set the header to Class 5, ID 22, Length 2 */
  769.     if (!cdcomhead(es, 5, 22, 2)) return 0;
  770.     es += 2;
  771.  
  772.     /* add in the value of inhatch */
  773.     es += cdAppShort(es, (short int) instyle);
  774.  
  775.     octet_count = 4; /* we just know this */
  776.  
  777.     /* add it to the buffer */
  778.     if (cdAddElem(im, esp, octet_count)) {
  779.         im->shapestyle = (short int) instyle;
  780.         free(esp);
  781.         return 1;
  782.     }
  783.     else {
  784.         free(esp);
  785.         return 0;
  786.     }
  787.  
  788.  
  789. }
  790.  
  791. int cdSetFillColor(cdImagePtr im, int incolor) {
  792. /* set the color of the interior of filled area elements
  793.  * Attribute: Fill Colour; Elem Class 5; Elem ID 23
  794.  * These attributes stay in effect until changed, so you don't have to output
  795.  * them every time.
  796.  *     Fill Colour: (index into the color table)
  797.  */
  798.     unsigned char *es, *esp;
  799.     int octet_count;
  800.     /* First check and see if the user doesn't want any changes,
  801.      * if so, just return success */
  802.     if (incolor == -1)
  803.         return 1;
  804.  
  805.     /* Check and see if the value it is being set to is the current
  806.      * value, if so, don't make any changes, just return 1 */
  807.     if (incolor == im->shapecolor)
  808.         return 1;
  809.  
  810.     /* Make sure the color they want to use has been allocated. 
  811.      * also, that color must be non-negative */
  812.     if ((incolor >= im->colorsTotal ) || (incolor < 0))
  813.         return 0;  /* you must allocate a color before you use it */
  814.  
  815.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  816.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  817.     if (!es) return 0; /* memory allocation failed */
  818.     esp=es;
  819.  
  820.     if (!cdcomhead(es, 5, 23, 1)) return 0;
  821.     es += 2;
  822.  
  823.     *es =  0377 & incolor; /* mask off last 8 bits and put in es */
  824.     es++;
  825.     es += cdAppNull(es, 1);
  826.  
  827.     octet_count = 4; /* we just know this; 2 octets of header,
  828.                       * 1 octet of data, 1 octet of null data */
  829.  
  830.         /* add it to the buffer */
  831.         if (cdAddElem(im, esp, octet_count)) {
  832.         im->shapecolor = (short int) incolor;
  833.                 free(esp);
  834.                 return 1;
  835.         }
  836.         else {
  837.                 free(esp);
  838.                 return 0;
  839.         }
  840.  
  841.  
  842.  
  843. }
  844.  
  845. int cdSetFillHatch(cdImagePtr im, int inhatch) {
  846. /* Set the hatch pattern for the interior of filled-area elements
  847.  * the fill style must be set to hatch for this to have an effect.
  848.  * Attribute: Hatch Index; Elem Class 5; Elem ID 24
  849.  * These attributes stay in effect until changed, so you don't have to output
  850.  * them every time.
  851.  *     Hatch Index: (integers 1-6, corresponding to: horizontal lines,
  852.  *                   vertical lines, pos. slope parallel lines,
  853.  *                   neg. slope parallel lines, horizontal/vertical
  854.  *                   crosshatch, positive/negative slope crosshatch)
  855.  */
  856.  
  857.     unsigned char *es, *esp;
  858.     int octet_count, temp;
  859.  
  860.  
  861.     /* First check and see if the user doesn't want any changes,
  862.      * if so, just return success */
  863.     if (inhatch == -1)
  864.         return 1;
  865.  
  866.     /* Check and see if the value it is being set to is the current
  867.      * value, if so, don't make any changes, just return 1 */
  868.     if (inhatch == im->shapehatch)
  869.         return 1;
  870.  
  871.     /* Make sure that lnhatch is between 1 and 6 */
  872.     if ((inhatch < 1) || (inhatch > 6))
  873.         return 0;
  874.  
  875.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  876.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  877.     if (!es) return 0; /* memory allocation failed */
  878.     esp=es;
  879.  
  880.     /* set the command header to class 5, id 24, length 2 */
  881.     if (!cdcomhead (es, 5, 24, 2)) return 0;
  882.     es += 2;
  883.  
  884.     /* add in the value of inhatch */
  885.     temp = inhatch >> 8;
  886.     *es = *es | (temp & 0377);
  887.     es++;
  888.     *es = *es | (inhatch & 0377);
  889.     es++;
  890.  
  891.     octet_count = 4; /* we just know this */
  892.  
  893.     /* add it to the buffer */
  894.     if (cdAddElem(im, esp, octet_count)) {
  895.         im->shapehatch = (short int) inhatch;
  896.         free(esp);
  897.         return 1;
  898.     }
  899.     else {
  900.         free(esp);
  901.         return 0;
  902.     }
  903.  
  904. }
  905.  
  906. int cdSetEdgeType(cdImagePtr im, int edtype) {
  907. /* set the type of the edge of filled-area elements.
  908.  * Attribute: Edge Type; Elem Class 5; Elem ID 27
  909.  * These attributes stay in effect until changed, so you don't have to output
  910.  * them every time.
  911.  *     Edge Type (integers 1-5, corresponding to: solid, dash, dot,
  912.  *                dash-dot, dash-dot-dot. These are the same as those used
  913.  *                for line type.)
  914.  * In Part 3 of the standard (Binary Encoding) on page 47 it says that
  915.  * edge type is integer.  This is incorrect.  Edge type is Index, just
  916.  * like line type.
  917.  * Even though new ones can be defined, I am limiting lntype to these values
  918.  * If you really need more, you can make the proper changes.
  919.  */
  920.     unsigned char *es, *esp;
  921.     int octet_count;
  922.  
  923.     /* First check and see if the user doesn't want any changes,
  924.      * if so, just return success */
  925.     if (edtype == -1)
  926.         return 1;
  927.  
  928.     /* Check and see if the value it is being set to is the current
  929.      * value, if so, don't make any changes, just return 1 */
  930.     if (edtype == im->edgetype)
  931.         return 1;
  932.  
  933.     /* Make sure that lntype is between 1 and 5 */
  934.     if ((edtype < 1) || (edtype > 5))
  935.         return 0;
  936.  
  937.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  938.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  939.     if (!es) return 0; /* memory allocation failed */
  940.     esp=es;
  941.  
  942.     if(!cdcomhead(es, 5, 27, 2)) return 0;
  943.     es += 2;
  944.  
  945.     /* add in the value of edtype */
  946.     es += cdAppShort(es, (short int) edtype);
  947.  
  948.     octet_count = 4; /* we just know this */
  949.  
  950.     /* add it to the buffer */
  951.     if (cdAddElem(im, esp, octet_count)) {
  952.         im->edgetype = (short int) edtype;
  953.         free(esp);
  954.         return 1;
  955.     }
  956.     else {
  957.         free(esp);
  958.         return 0;
  959.     }
  960.  
  961.  
  962. }
  963.  
  964. int cdSetEdgeWidth(cdImagePtr im, int edwidth) {
  965. /* Set the width of the edge of filled-area elements.
  966.  * Attribute: Edge Width; Elem Class 5; Elem ID 28
  967.  * These attributes stay in effect until changed, so you don't have to output
  968.  * them every time.
  969.  *     Edge Width (should be the same as line width)
  970.  */
  971.     unsigned char *es, *esp;
  972.     int octet_count, temp;
  973.  
  974.     /* First check and see if the user doesn't want any changes,
  975.      * if so, just return success */
  976.     if (edwidth == -1)
  977.         return 1;
  978.  
  979.     /* Check and see if the value it is being set to is the current
  980.      * value, if so, don't make any changes, just return 1 */
  981.     if (edwidth == im->edgewidth)
  982.         return 1;
  983.  
  984.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  985.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  986.     if (!es) return 0; /* memory allocation failed */
  987.     esp=es;
  988.  
  989.     octet_count = 2;
  990.     if (!cdcomhead(es, 5, 28, 4)) return 0;
  991.     es += 2;
  992.  
  993.     /*gej: edge width is 32 bit floating point number, 16 bits before the
  994.      * decimal, 16 bits after.   */
  995.     es++; octet_count++;
  996.     temp = edwidth >> 8;
  997.     *es = *es | (temp & 0377);
  998.     es++; octet_count++;
  999.     *es = *es | (edwidth & 0377);
  1000.     /* the next two (after decimal point) will always be zero */
  1001.     es += cdAppNull(es, 2);
  1002.     octet_count+=2;
  1003.     
  1004.     
  1005.     /* add it to the buffer */
  1006.     if (cdAddElem(im, esp, octet_count)) {
  1007.         im->edgewidth = edwidth;
  1008.         free(esp);
  1009.         return 1;
  1010.     }
  1011.     else {
  1012.         free(esp);
  1013.         return 0;
  1014.     }
  1015.  
  1016.  
  1017.  
  1018. }
  1019.  
  1020. int cdSetEdgeColor(cdImagePtr im, int edcolor) {
  1021. /* Set the color of the edge of filled-area elements.
  1022.  * Attribute: Edge Color; Elem Class 5; Elem ID 29
  1023.  * These attributes stay in effect until changed, so you don't have to output
  1024.  * them every time.
  1025.  *     Edge Colour (index into the color table)
  1026.  */
  1027.     unsigned char *es, *esp;
  1028.     int octet_count;
  1029.     /* First check and see if the user doesn't want any changes,
  1030.      * if so, just return success */
  1031.     if (edcolor == -1)
  1032.         return 1;
  1033.  
  1034.     /* Check and see if the value it is being set to is the current
  1035.      * value, if so, don't make any changes, just return 1 */
  1036.     if (edcolor == im->edgecolor)
  1037.         return 1;
  1038.  
  1039.     /* Make sure the color they want to use has been allocated. 
  1040.      * also, that color must be non-negative */
  1041.     if ((edcolor >= im->colorsTotal ) || (edcolor < 0))
  1042.         return 0;  /* you must allocate a color before you use it */
  1043.  
  1044.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1045.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1046.     if (!es) return 0; /* memory allocation failed */
  1047.     esp=es;
  1048.     if (!cdcomhead(es, 5, 29, 1)) return 0;
  1049.     es += 2;
  1050.  
  1051.     *es =  0377 & edcolor; /* mask off last 8 bits and put in es */
  1052.     es++;
  1053.     es += cdAppNull(es, 1);
  1054.  
  1055.     octet_count = 4; /* we just know this; 2 octets of header,
  1056.                       * 1 octet of data, 1 octet of null data */
  1057.  
  1058.         /* add it to the buffer */
  1059.         if (cdAddElem(im, esp, octet_count)) {
  1060.         im->edgecolor = (short int) edcolor;
  1061.                 free(esp);
  1062.                 return 1;
  1063.         }
  1064.         else {
  1065.                 free(esp);
  1066.                 return 0;
  1067.         }
  1068.  
  1069.  
  1070.  
  1071. }
  1072.  
  1073. int cdSetEdgeVis(cdImagePtr im, int edvis) {
  1074. /* Set the visibility of the edge of filled-area elements.
  1075.  * Attribute: Edge Visibility; Elem Class 5; Elem ID 30
  1076.  * These attributes stay in effect until changed, so you don't have to output
  1077.  * them every time.
  1078.  *     Edge Visibility (integer 0 or 1, corresponding to: Off, On)
  1079.  * Attribute is 16 bit signed int.
  1080.  */
  1081.     unsigned char *es, *esp;
  1082.     int octet_count, temp;
  1083.  
  1084.     /* First check and see if the user doesn't want any changes,
  1085.      * if so, just return success */
  1086.     if (edvis == -1)
  1087.         return 1;
  1088.  
  1089.     /* Check and see if the value it is being set to is the current
  1090.      * value, if so, don't make any changes, just return 1 */
  1091.     if (edvis == im->edgevis)
  1092.         return 1;
  1093.  
  1094.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1095.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1096.     if (!es) return 0; /* memory allocation failed */
  1097.     esp=es;
  1098.  
  1099.     if (!cdcomhead(es, 5, 30, 2)) return 0;
  1100.     es +=2; octet_count = 2;
  1101.     temp = edvis >> 8;
  1102.     *es = *es | (temp & 0377);
  1103.     es++;
  1104.     *es = *es | (edvis & 0377);
  1105.     es++;
  1106.     octet_count += 2;
  1107.     
  1108.     
  1109.     /* add it to the buffer */
  1110.     if (cdAddElem(im, esp, octet_count)) {
  1111.         im->edgevis = (short int) edvis;
  1112.         free(esp);
  1113.         return 1;
  1114.     }
  1115.     else {
  1116.         free(esp);
  1117.         return 0;
  1118.     }
  1119.  
  1120.  
  1121. }
  1122.  
  1123. int cdSetTextFont(cdImagePtr im, int font) {
  1124. /* Attribute: Text Font Index; Elem Class 5; Elem ID 10
  1125.  * font is an index into the font table.  it can have one of the following
  1126.  * values:
  1127.  *  1 Times
  1128.  *  2 Times Bold
  1129.  *  3 Times Italic
  1130.  *  4 Times Bold Italic
  1131.  *  5 Helvetica
  1132.  *  6 Helvetica Bold
  1133.  *  7 Helvetica Italic
  1134.  *  8 Helvetica Bold Italic
  1135.  *  9 Courier
  1136.  * 10 Courier Bold
  1137.  * 11 Courier Italic
  1138.  * 12 Courier Bold Italic
  1139.  * 13 Symbol
  1140.  */
  1141.     unsigned char *es, *esp;
  1142.     int octet_count;
  1143.  
  1144.     /* First check and see if the user doesn't want any changes,
  1145.      * if so, just return success */
  1146.     if (font == -1)
  1147.         return 1;
  1148.  
  1149.     /* Check and see if the value it is being set to is the current
  1150.      * value, if so, don't make any changes, just return 1 */
  1151.     if (font == im->textfont)
  1152.         return 1;
  1153.  
  1154.     /* Make sure that font is between 1 and numberOfFonts */
  1155.     if ((font < 1) || (font > numberOfFonts))
  1156.         return 0;
  1157.  
  1158.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1159.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1160.     if (!es) return 0; /* memory allocation failed */
  1161.     esp=es;
  1162.  
  1163.     if(!cdcomhead(es, 5, 10, 2)) return 0;
  1164.     es += 2;
  1165.  
  1166.     es += cdAppShort(es, (short int) font);
  1167.  
  1168.     octet_count = 4; /* we just know this */
  1169.  
  1170.     /* add it to the buffer */
  1171.     if (cdAddElem(im, esp, octet_count)) {
  1172.         im->textfont = (short int) font;
  1173.         free(esp);
  1174.         return 1;
  1175.     }
  1176.     else {
  1177.         free(esp);
  1178.         return 0;
  1179.     }
  1180.  
  1181. }
  1182.  
  1183. int cdSetTextColor(cdImagePtr im, int color) {
  1184. /* Attribute: Text Colour ; Elem Class 5; Elem ID 14
  1185.  * set the forground color of text
  1186.  */
  1187.     unsigned char *es, *esp;
  1188.     int octet_count;
  1189.     /* First check and see if the user doesn't want any changes,
  1190.      * if so, just return success */
  1191.     if (color == -1)
  1192.         return 1;
  1193.  
  1194.     /* Check and see if the value it is being set to is the current
  1195.      * value, if so, don't make any changes, just return 1 */
  1196.     if (color == im->textcolor)
  1197.         return 1;
  1198.  
  1199.     /* Make sure the color they want to use has been allocated. 
  1200.      * also, that color must be non-negative */
  1201.     if ((color >= im->colorsTotal ) || (color < 0))
  1202.         return 0;  /* you must allocate a color before you use it */
  1203.  
  1204.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1205.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1206.     if (!es) return 0; /* memory allocation failed */
  1207.     esp=es;
  1208.  
  1209.     if(!cdcomhead(es, 5, 14, 1)) return 0;
  1210.     es += 2; 
  1211.  
  1212.     *es =  0377 & color; /* mask off last 8 bits and put in es */
  1213.     es++;
  1214.  
  1215.     octet_count = 4; /* we just know this; 2 octets of header,
  1216.                       * 1 octet of data, 1 octet of null data */
  1217.  
  1218.         /* add it to the buffer */
  1219.         if (cdAddElem(im, esp, octet_count)) {
  1220.         im->textcolor = (short int) color;
  1221.                 free(esp);
  1222.                 return 1;
  1223.         }
  1224.         else {
  1225.                 free(esp);
  1226.                 return 0;
  1227.         }
  1228.  
  1229. }
  1230.  
  1231. int cdSetTextHeight(cdImagePtr im, int height) {
  1232. /* Attribute: Character Height; Elem Class 5; Elem ID 15
  1233.  * the height is in the same units as line width
  1234.  */
  1235.     unsigned char *es, *esp;
  1236.     int octet_count;
  1237.     /* First check and see if the user doesn't want any changes,
  1238.      * if so, just return success */
  1239.     if (height == -1)
  1240.         return 1;
  1241.  
  1242.     /* Check and see if the value it is being set to is the current
  1243.      * value, if so, don't make any changes, just return 1 */
  1244.     if (height == im->textheight)
  1245.         return 1;
  1246.  
  1247.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1248.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1249.     if (!es) return 0; /* memory allocation failed */
  1250.     esp=es;
  1251.  
  1252.     if(!cdcomhead(es, 5, 15, 2)) return 0;
  1253.     octet_count = 2; es += 2;
  1254.  
  1255.     es += cdAppShort(es, height);
  1256.     octet_count += 2;
  1257.  
  1258.         /* add it to the buffer */
  1259.         if (cdAddElem(im, esp, octet_count)) {
  1260.         im->textheight = height;
  1261.                 free(esp);
  1262.                 return 1;
  1263.         }
  1264.         else {
  1265.                 free(esp);
  1266.                 return 0;
  1267.         }
  1268.  
  1269. }
  1270.  
  1271. int cdSetTextPath(cdImagePtr im, int tpath) {
  1272. /* Attribute: Text Path; Elem Class 5; Elem ID 17
  1273.  * Is one of:
  1274.  *   0 right -- Means the direction of the character base vector
  1275.  *   1 left  -- means 180 degrees from the character base vector
  1276.  *   2 up    -- means the direction of the character up vector
  1277.  *   3 down  -- means 180 degrees from the character up vector
  1278.  */
  1279.     unsigned char *es, *esp;
  1280.     int octet_count;
  1281.  
  1282.     /* First check and see if the user doesn't want any changes,
  1283.      * if so, just return success */
  1284.     if (tpath == -1)
  1285.         return 1;
  1286.  
  1287.     /* Check and see if the value it is being set to is the current
  1288.      * value, if so, don't make any changes, just return 1 */
  1289.     if (tpath == im->textpath)
  1290.         return 1;
  1291.  
  1292.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1293.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1294.     if (!es) return 0; /* memory allocation failed */
  1295.     esp=es;
  1296.     octet_count = 0;
  1297.  
  1298.     if (!cdcomhead(es, 5, 17, 2)) return 0;
  1299.     es +=2; octet_count = 2;
  1300.  
  1301.     es += cdAppShort(es, (short int) tpath);
  1302.     octet_count += 2;
  1303.  
  1304.         /* add it to the buffer */
  1305.         if (cdAddElem(im, esp, octet_count)) {
  1306.         im->textpath = (short int) tpath;
  1307.                 free(esp);
  1308.                 return 1;
  1309.         }
  1310.         else {
  1311.                 free(esp);
  1312.                 return 0;
  1313.         }
  1314.  
  1315. }
  1316.  
  1317. int cdSetTextOrient(cdImagePtr im, int xup, int yup, int xbase, int ybase) {
  1318. /* Attribute: Character Orientation; Elem Class 5; Elem ID 16
  1319.  * (xbase,ybase) is the run and the rise of the line that the text is
  1320.  * written along.  For regular text at an angle, set xup = -ybase
  1321.  * and yup = xbase.  Setting it to something different will result in
  1322.  * skewed text (which may be what you want.) Text written from bottom to
  1323.  * top at a 90 degree angle would have the following parameters  
  1324.  * xup=-1, yup=0, xbase=0, ybase=1
  1325.  *
  1326.  * This function adds the Orientation to the metafile every time.
  1327.  * It does not follow the normal -1 for no change, although if you
  1328.  * put in the same numbers it won't re-add it to the meta file.
  1329.  */
  1330.     unsigned char *es, *esp;
  1331.     int octet_count;
  1332.  
  1333.  
  1334.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1335.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1336.     if (!es) return 0; /* memory allocation failed */
  1337.     esp=es;
  1338.     octet_count = 0;
  1339.  
  1340.     if (!cdcomhead(es, 5, 16, 8)) return 0;
  1341.     es +=2; octet_count += 2;
  1342.  
  1343.     /* In the metafile it is a 16 bit signed integer */
  1344.     /* add xup */
  1345.     es += cdAppShort(es, (short int) xup);
  1346.     octet_count += 2;
  1347.     /* add the rest */
  1348.     es += cdAppShort(es, (short int) yup);
  1349.     octet_count += 2;
  1350.     es += cdAppShort(es, (short int) xbase);
  1351.     octet_count += 2;
  1352.     es += cdAppShort(es, (short int) ybase);
  1353.     octet_count += 2;
  1354.  
  1355.         /* add it to the buffer */
  1356.         if (cdAddElem(im, esp, octet_count)) {
  1357.                 free(esp);
  1358.                 return 1;
  1359.         }
  1360.         else {
  1361.                 free(esp);
  1362.                 return 0;
  1363.         }
  1364.  
  1365. }
  1366.  
  1367. int cdSetLineAttrib(cdImagePtr im, int lntype, int lnwidth, int lncolor) {
  1368. /* Spits out the attributes of lines.  These attributes stay in effect
  1369.  * until changed, so you don't have to output them every time.
  1370.  */
  1371.  
  1372.     if (!cdSetLineType(im, lntype)) return 0;
  1373.     if (!cdSetLineWidth(im, lnwidth)) return 0;
  1374.     if (!cdSetLineColor(im, lncolor)) return 0;
  1375.  
  1376.     return 1;
  1377.  
  1378. }
  1379.  
  1380. int cdSetShapeFillAttrib(cdImagePtr im, int instyle, int incolor, int inhatch) {
  1381. /* Spits out the attributes for the interior of filled-area elements.
  1382.  * These attributes stay in effect until changed, so you don't have to output
  1383.  * them every time.
  1384.  * Set the following attributes:
  1385.  *     Interior Style: (integers 0-6, corresponding to: hollow, solid, 
  1386.  *                      [not pattern], hatch, empty, [not geometric pattern], 
  1387.  *                      interpolated.)
  1388.  *     Fill Colour: (index into the color table)
  1389.  *     Hatch Index: (integers 1-6, corresponding to: horizontal lines, 
  1390.  *                   vertical lines, pos. slope parallel lines, 
  1391.  *                   neg. slope parallel lines, horizontal/vertical
  1392.  *                   crosshatch, positive/negative slope crosshatch)
  1393.  */
  1394.     if (!cdSetFillStyle(im, instyle)) return 0;
  1395.     if (!cdSetFillColor(im, incolor)) return 0;
  1396.     if (!cdSetFillHatch(im, inhatch)) return 0;
  1397.  
  1398.     return 1;
  1399. }
  1400.  
  1401. int cdSetShapeEdgeAttrib(cdImagePtr im, int edtype, int edwidth, int edcolor, int edvis) {
  1402. /* Spits out the attributes for the edges of filled-area elements.  It may
  1403.  * seem logical that these would be the same as the corresponding line 
  1404.  * attributes, but this is not the case.
  1405.  * These attributes stay in effect until changed, so you don't have to output
  1406.  * them every time.
  1407.  * Set the following attributes:
  1408.  *     Edge Type (integers 1-5, corresponding to: solid, dash, dot,
  1409.  *                dash-dot, dash-dot-dot. These are the same as those used
  1410.  *                for line type.)
  1411.  *     Edge Width (should be the same as line width)
  1412.  *     Edge Colour (index into the color table)
  1413.  *     Edge Visibility (integer 0 or 1, corresponding to: Off, On)
  1414.  */
  1415.     if (!cdSetEdgeType(im, edtype)) return 0;
  1416.     if (!cdSetEdgeWidth(im, edwidth)) return 0;
  1417.     if (!cdSetEdgeColor(im, edcolor)) return 0;
  1418.     if (!cdSetEdgeVis(im, edvis)) return 0;
  1419.  
  1420.     return 1;
  1421. }
  1422.  
  1423. int cdSetTextAttrib(cdImagePtr im, int font, int color, int height) {
  1424. /* Set the attributes of text.  the font is an integer pointer into the
  1425.  * font list where:
  1426.  *  1 Times
  1427.  *  2 Times Bold
  1428.  *  3 Times Italic
  1429.  *  4 Times Bold Italic
  1430.  *  5 Helvetica
  1431.  *  6 Helvetica Bold
  1432.  *  7 Helvetica Italic
  1433.  *  8 Helvetica Bold Italic
  1434.  *  9 Courier
  1435.  * 10 Courier Bold
  1436.  * 11 Courier Italic
  1437.  * 12 Courier Bold Italic
  1438.  * 13 Symbol
  1439.  * color is an index into the colortable which is the color of the text
  1440.  * size is the approximate size you want the text written in.
  1441.  */
  1442.  
  1443.     if(!cdSetTextFont(im, font))   return 0;
  1444.     if(!cdSetTextColor(im, color)) return 0;
  1445.     if(!cdSetTextHeight(im, height)) return 0;
  1446.  
  1447.     return 1;
  1448. }
  1449.  
  1450.  
  1451. int cdImageDestroy(cdImagePtr im)
  1452. /* gej: should work, unless I make changes to cdImage Struct */
  1453. {
  1454.     if (im->elemlist) {
  1455.         free(im->elemlist);
  1456.     }
  1457.     free(im);
  1458.  
  1459.     return 1;
  1460. }
  1461.  
  1462. int cdImageColorClosest(cdImagePtr im, int r, int g, int b)
  1463. /* From gd library, see README file for copyright information */
  1464. /* gej: should work unchanged */
  1465. /* gej: 5/96, changed the colors to use short int */
  1466. {
  1467.     short int i;
  1468.     long rd, gd, bd;
  1469.     int ct = (-1);
  1470.     long mindist = 0;
  1471.     for (i=0; (i<(im->colorsTotal)); i++) {
  1472.         long dist;
  1473.         if (im->open[i]) {
  1474.             continue;
  1475.         }
  1476.         rd = (im->red[i] - r);    
  1477.         gd = (im->green[i] - g);
  1478.         bd = (im->blue[i] - b);
  1479.         dist = rd * rd + gd * gd + bd * bd;
  1480.         if ((i == 0) || (dist < mindist)) {
  1481.             mindist = dist;    
  1482.             ct = i;
  1483.         }
  1484.     }
  1485.     return ct;
  1486. }
  1487.  
  1488. int cdImageColorClear(cdImagePtr im) {
  1489. /* mark all entries in the color table as open */
  1490.     short int i;
  1491.     for (i=0; (i<(cdMaxColors)); i++) {
  1492.         im->open[i] = 1;
  1493.     }
  1494.     return 1;
  1495. }
  1496.  
  1497. int cdImageColorExact(cdImagePtr im, int r, int g, int b)
  1498. /* From gd library, see README file for copyright information */
  1499. /* gej: should work unchanged */
  1500. /* gej: 5/96, changed colors to work with short ints */
  1501. {
  1502.     short int i;
  1503.     for (i=0; (i<(im->colorsTotal)); i++) {
  1504.         if (im->open[i]) {
  1505.             continue;
  1506.         }
  1507.         if ((im->red[i] == r) && 
  1508.             (im->green[i] == g) &&
  1509.             (im->blue[i] == b)) {
  1510.             return i;
  1511.         }
  1512.     }
  1513.     return -1;
  1514. }
  1515.  
  1516. static int cdImageAddColor(cdImagePtr im, int ct, int r, int g, int b)
  1517. /* adds a color to the cgm file.  Does not allocate it in the
  1518.  * cdImagePtr object.  Use cdImageColorAllocate, not this one.
  1519.  */
  1520. {
  1521.     unsigned char *cts, *ctsp; /* GEJ: color table attribute */
  1522.     int octet_count; /* GEJ: octet count */
  1523.     /*
  1524.      * Attribute: Colour Table; Elem Class 5; Elem ID 34
  1525.      * two parameters P1: Starting colour table index (1 octet, UI)
  1526.      * P2: list of direct colour values 3-tuples (3 one-octet values)
  1527.      */
  1528.      /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1529.         cts = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1530.         if (!cts) return -1; /* memory allocation failed */
  1531.         ctsp=cts;
  1532.     *ctsp = *ctsp | b6 | b4; /* set elem class to 5 */
  1533.     *ctsp = *ctsp | b2; /* set elem id to 34 */
  1534.     ctsp++;
  1535.     *ctsp = *ctsp | b6;
  1536.     *ctsp = *ctsp | b2; /* set param list len to 4 */
  1537.     ctsp++;
  1538.     octet_count = 2; /* so far */
  1539.     /* now fill in the index number */
  1540.     *ctsp =  (unsigned char) 0377 & ct; /* mask off last 8 bits and put in ctsp*/
  1541.     ctsp++;octet_count++;
  1542.     /* now fill in the RGB values */
  1543.     *ctsp =  (unsigned char) 0377 & r; /* mask off last 8 bits and put in ctsp*/
  1544.     ctsp++;octet_count++;
  1545.     *ctsp =  (unsigned char) 0377 & g; /* mask off last 8 bits and put in ctsp*/
  1546.     ctsp++;octet_count++;
  1547.     *ctsp =  (unsigned char) 0377 & b; /* mask off last 8 bits and put in ctsp*/
  1548.     ctsp++;octet_count++;
  1549.         /* add it to the buffer */
  1550.         if (cdAddElem(im, cts, octet_count)) {
  1551.                 free(cts);
  1552.                 return 1;
  1553.         }
  1554.         else {
  1555.                 free(cts);
  1556.                 return -1;
  1557.         }
  1558.     
  1559.     
  1560. }
  1561.  
  1562. int cdImageColorAllocate(cdImagePtr im, int r, int g, int b)
  1563. /* From gd library, see README file for copyright information
  1564.  * gej: modified to allocate the color in the CGM buffer as well
  1565.  * as the color table */
  1566. /* gej: 5/96, modified to use short ints for colors */
  1567. {
  1568.     short int i;
  1569.     short int ct = (-1);
  1570.     for (i=0; (i<(im->colorsTotal)); i++) {
  1571.         if (im->open[i]) {
  1572.             ct = i;
  1573.             break;
  1574.         }
  1575.     }    
  1576.     if (ct == (-1)) {
  1577.         ct = im->colorsTotal;
  1578.         if (ct == cdMaxColors) {
  1579.             return -1;
  1580.         }
  1581.         im->colorsTotal++;
  1582.     }
  1583.     im->red[ct] = (short int) r;
  1584.     im->green[ct] = (short int) g;
  1585.     im->blue[ct] = (short int) b;
  1586.     im->open[ct] = (short int) 0;
  1587.     /* GEJ: Now we have successfully alocated it in the color table
  1588.      * so let's put it in the CGM as well. 
  1589.      */
  1590.     if (!cdImageAddColor(im, ct, r, g, b) ) {
  1591.         return -1;
  1592.     }
  1593.     else {
  1594.         return ct;
  1595.     }
  1596.  
  1597. }
  1598.  
  1599. int cdImageColor16(cdImagePtr im) {
  1600. /* allocate the 16 basic colors in the windows pallete */
  1601.     if( -1 == cdImageColorAllocate(im, 255, 255, 255)) return 0;
  1602.     if( -1 == cdImageColorAllocate(im, 0, 0, 0)) return 0;
  1603.     if( -1 == cdImageColorAllocate(im, 128, 0, 0)) return 0;
  1604.     if( -1 == cdImageColorAllocate(im, 0, 128, 0)) return 0;
  1605.     if( -1 == cdImageColorAllocate(im, 128, 128, 0)) return 0;
  1606.     if( -1 == cdImageColorAllocate(im, 0, 0, 128)) return 0;
  1607.     if( -1 == cdImageColorAllocate(im, 128, 0, 128)) return 0;
  1608.     if( -1 == cdImageColorAllocate(im, 0, 128, 128)) return 0;
  1609.     if( -1 == cdImageColorAllocate(im, 128, 128, 128)) return 0;
  1610.     if( -1 == cdImageColorAllocate(im, 192, 192, 192)) return 0;
  1611.     if( -1 == cdImageColorAllocate(im, 255, 0, 0)) return 0;
  1612.     if( -1 == cdImageColorAllocate(im, 0, 255, 0)) return 0;
  1613.     if( -1 == cdImageColorAllocate(im, 255, 255, 0)) return 0;
  1614.     if( -1 == cdImageColorAllocate(im, 0, 0, 255)) return 0;
  1615.     if( -1 == cdImageColorAllocate(im, 255, 0, 255)) return 0;
  1616.     if( -1 == cdImageColorAllocate(im, 0, 255, 255)) return 0;
  1617.  
  1618.     return 1;
  1619.  
  1620. }
  1621.  
  1622. int cdImageColorDeallocate(cdImagePtr im, int color)
  1623. /* From gd library, see README file for copyright information */
  1624. /* gej: should work unchanged */
  1625. {
  1626.     /* Mark it open. */
  1627.     /*im->open[color] = 1;*/
  1628.     /* gej: really can't work, we are not allowing redefinition
  1629.      * of color table entries */
  1630.     return 0;
  1631. }
  1632.  
  1633. int cdLine(cdImagePtr im, int x1, int y1, int x2, int y2)
  1634. /* Graphic Primitive: Polyline; Elem Class 4; Elem ID 1
  1635.  * Actually generate the line, if you are writing a program to use this
  1636.  * library, use this function, not cdImageLine or cdImageDashedLine,
  1637.  * those are just in for compatiblilty with gd 
  1638.  *
  1639.  * This function will draw a line using the current line type, width, and color
  1640.  */
  1641. {
  1642.  
  1643.     unsigned char *es, *esp;
  1644.     int octet_count;
  1645.     short int sweet;
  1646.     short int sour;
  1647.  
  1648.     /* check to make sure the line is withing the scope of the picture
  1649.      * ie. the values you give for drawing the line are within
  1650.      * the values you created the picture with */
  1651.     if (!(cdImageBoundsSafe(im, x1,y1)) || !(cdImageBoundsSafe(im, x2,y2)))
  1652.         return 0;
  1653.  
  1654.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1655.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1656.     if (!es) return 0; /* memory allocation failed */
  1657.     esp=es;
  1658.  
  1659.     if (!cdcomhead(es, 4, 1, 8)) return 0;
  1660.     es += 2;
  1661.     octet_count = 2;
  1662.  
  1663.     /* now we are ready for the parameter data */
  1664.     sweet = (short int) x1;
  1665.     sour = sweet >> 8;
  1666.     *es = *es | (sour & 0377);
  1667.     es++; octet_count++;
  1668.     *es = (unsigned char) sweet;
  1669.     es++; octet_count++;
  1670.     sweet = (short int) y1;
  1671.     sour = sweet >> 8;
  1672.     *es = *es | (sour & 0377);
  1673.     es++; octet_count++;
  1674.     *es = (unsigned char) sweet;
  1675.     es++; octet_count++;
  1676.     sweet = (short int) x2;
  1677.     sour = sweet >> 8;
  1678.     *es = *es | (sour & 0377);
  1679.     es++; octet_count++;
  1680.     *es = (unsigned char) sweet;
  1681.     es++; octet_count++;
  1682.     sweet = (short int) y2;
  1683.     sour = sweet >> 8;
  1684.     *es = *es | (sour & 0377);
  1685.     es++; octet_count++;
  1686.     *es = (unsigned char) sweet;
  1687.     octet_count++;
  1688.  
  1689.         /* add it to the buffer */
  1690.         if (cdAddElem(im, esp, octet_count)) {
  1691.                 free(esp);
  1692.                 return 1;
  1693.         }
  1694.         else {
  1695.                 free(esp);
  1696.                 return 0;
  1697.         }
  1698.  
  1699.  
  1700.  
  1701. }
  1702.  
  1703. int cdRectangle(cdImagePtr im, int x1, int y1, int x2, int y2) {
  1704. /* Graphic Primitive: rectangle; Elem Class 4; Elem ID 11
  1705.  * Actually generate the rectangle, if you are writing a program to use this
  1706.  * library, use this function, not cdImageRectangle,
  1707.  * those are just in for compatiblilty with gd 
  1708.  *
  1709.  * This function will draw a Rectangle using the current 
  1710.  * edge type, width, color, and visibility, and the current
  1711.  * fill style, color, and hatch
  1712.  */
  1713.     unsigned char *es, *esp;
  1714.     int octet_count;
  1715.     short int sweet;
  1716.     short int sour;
  1717.  
  1718.     /* check to make sure the line is withing the scope of the picture
  1719.      * ie. the values you give for drawing the line are within
  1720.      * the values you created the picture with */
  1721.     if (!(cdImageBoundsSafe(im, x1,y1)) || !(cdImageBoundsSafe(im, x2,y2)))
  1722.         return 0;
  1723.  
  1724.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1725.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1726.     if (!es) return 0; /* memory allocation failed */
  1727.     esp=es;
  1728.  
  1729.     /* their are four 16 bit signed integers as attributes */
  1730.     if (!cdcomhead(es, 4, 11, 8)) return 0;
  1731.     es +=2; octet_count = 2;
  1732.  
  1733.     /* now we are ready for the parameter data */
  1734.     sweet = (short int) x1;
  1735.     sour = sweet >> 8;
  1736.     *es = *es | (sour & 0377);
  1737.     es++; octet_count++;
  1738.     *es = (unsigned char) sweet;
  1739.     es++; octet_count++;
  1740.     sweet = (short int) y1;
  1741.     sour = sweet >> 8;
  1742.     *es = *es | (sour & 0377);
  1743.     es++; octet_count++;
  1744.     *es = (unsigned char) sweet;
  1745.     es++; octet_count++;
  1746.     sweet = (short int) x2;
  1747.     sour = sweet >> 8;
  1748.     *es = *es | (sour & 0377);
  1749.     es++; octet_count++;
  1750.     *es = (unsigned char) sweet;
  1751.     es++; octet_count++;
  1752.     sweet = (short int) y2;
  1753.     sour = sweet >> 8;
  1754.     *es = *es | (sour & 0377);
  1755.     es++; octet_count++;
  1756.     *es = (unsigned char) sweet;
  1757.     octet_count++;
  1758.  
  1759.         /* add it to the buffer */
  1760.         if (cdAddElem(im, esp, octet_count)) {
  1761.                 free(esp);
  1762.                 return 1;
  1763.         }
  1764.         else {
  1765.                 free(esp);
  1766.                 return 0;
  1767.         }
  1768.  
  1769.  
  1770.  
  1771. }
  1772.  
  1773. int cdCircle(cdImagePtr im, int cx, int cy, int r) {
  1774. /* Graphic Primitive: circle; Elem Class 4; Elem ID 12
  1775.  * cx,cy is the center of the circle, r is the radius
  1776.  *
  1777.  * This function will draw a Circle using the current 
  1778.  * edge type, width, color, and visibility, and the current
  1779.  * fill style, color, and hatch
  1780.  */
  1781.     unsigned char *es, *esp;
  1782.     int octet_count;
  1783.     short int sweet;
  1784.     short int sour;
  1785.  
  1786.     /* check to make sure the circle is withing the scope of the picture
  1787.      * ie. the values you give for drawing the circle are within
  1788.      * the values you created the picture with */
  1789.     if (!(cdImageBoundsSafe(im, cx,cy)))
  1790.         return 0;
  1791.  
  1792.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1793.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1794.     if (!es) return 0; /* memory allocation failed */
  1795.     esp=es;
  1796.  
  1797.     /* their are three 16 bit signed integers as attributes */
  1798.     if (!cdcomhead(es, 4, 12, 6)) return 0;
  1799.     es +=2; octet_count = 2;
  1800.  
  1801.     /* now we are ready for the parameter data */
  1802.     sweet = (short int) cx;
  1803.     sour = sweet >> 8;
  1804.     *es = *es | (sour & 0377);
  1805.     es++; octet_count++;
  1806.     *es = (unsigned char) sweet;
  1807.     es++; octet_count++;
  1808.     sweet = (short int) cy;
  1809.     sour = sweet >> 8;
  1810.     *es = *es | (sour & 0377);
  1811.     es++; octet_count++;
  1812.     *es = (unsigned char) sweet;
  1813.     es++; octet_count++;
  1814.     sweet = (short int) r;
  1815.     sour = sweet >> 8;
  1816.     *es = *es | (sour & 0377);
  1817.     es++; octet_count++;
  1818.     *es = (unsigned char) sweet;
  1819.     octet_count++;
  1820.  
  1821.  
  1822.         /* add it to the buffer */
  1823.         if (cdAddElem(im, esp, octet_count)) {
  1824.                 free(esp);
  1825.                 return 1;
  1826.         }
  1827.         else {
  1828.                 free(esp);
  1829.                 return 0;
  1830.         }
  1831.  
  1832.  
  1833.  
  1834. }
  1835.  
  1836. int cdArc3Pt(cdImagePtr im, int sx,int sy, int ix,int iy, int ex,int ey) {
  1837. /* Graphic Primitive: Cicular Arc 3 Point; Elem Class 4; Elem ID 13
  1838.  *
  1839.  * This function will draw a Circular Arc using the current 
  1840.  * Line type, width, and color, 
  1841.  */
  1842.     unsigned char *es, *esp;
  1843.     int octet_count;
  1844.     short int sweet;
  1845.     short int sour;
  1846.  
  1847.     /* check to make sure the line is withing the scope of the picture
  1848.      * ie. the values you give for drawing the line are within
  1849.      * the values you created the picture with */
  1850.     if (!(cdImageBoundsSafe(im, sx,sy)) || !(cdImageBoundsSafe(im, ix,iy)) || !(cdImageBoundsSafe(im, ex, ey)))
  1851.         return 0;
  1852.  
  1853.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1854.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1855.     if (!es) return 0; /* memory allocation failed */
  1856.     esp=es;
  1857.  
  1858.     /* their are six 16 bit signed integers as attributes */
  1859.     if (!cdcomhead(es, 4, 13, 12)) return 0;
  1860.     es +=2; octet_count = 2;
  1861.  
  1862.     /* now we are ready for the parameter data */
  1863.     sweet = (short int) sx;
  1864.     sour = sweet >> 8;
  1865.     *es = *es | (sour & 0377);
  1866.     es++; octet_count++;
  1867.     *es = (unsigned char) sweet;
  1868.     es++; octet_count++;
  1869.     sweet = (short int) sy;
  1870.     sour = sweet >> 8;
  1871.     *es = *es | (sour & 0377);
  1872.     es++; octet_count++;
  1873.     *es = (unsigned char) sweet;
  1874.     es++; octet_count++;
  1875.     sweet = (short int) ix;
  1876.     sour = sweet >> 8;
  1877.     *es = *es | (sour & 0377);
  1878.     es++; octet_count++;
  1879.     *es = (unsigned char) sweet;
  1880.     es++; octet_count++;
  1881.     sweet = (short int) iy;
  1882.     sour = sweet >> 8;
  1883.     *es = *es | (sour & 0377);
  1884.     es++; octet_count++;
  1885.     *es = (unsigned char) sweet;
  1886.     es++; octet_count++;
  1887.     sweet = (short int) ex;
  1888.     sour = sweet >> 8;
  1889.     *es = *es | (sour & 0377);
  1890.     es++; octet_count++;
  1891.     *es = (unsigned char) sweet;
  1892.     es++; octet_count++;
  1893.     sweet = (short int) ey;
  1894.     sour = sweet >> 8;
  1895.     *es = *es | (sour & 0377);
  1896.     es++; octet_count++;
  1897.     *es = (unsigned char) sweet;
  1898.     octet_count++;
  1899.  
  1900.  
  1901.         /* add it to the buffer */
  1902.         if (cdAddElem(im, esp, octet_count)) {
  1903.                 free(esp);
  1904.                 return 1;
  1905.         }
  1906.         else {
  1907.                 free(esp);
  1908.                 return 0;
  1909.         }
  1910.  
  1911.  
  1912. }
  1913.  
  1914. int cdArc3PtClose(cdImagePtr im, int sx,int sy, int ix,int iy, int ex,int ey, int cl) {
  1915. /* Graphic Primitive: Cicular Arc 3 Point Close; Elem Class 4; Elem ID 14
  1916.  *
  1917.  * This function will draw a Circle using the current 
  1918.  * edge type, width, color, and visibility, and the current
  1919.  * fill style, color, and hatch
  1920.  *
  1921.  * cd is the closure type.  It can be either 0 for pie closure or
  1922.  * 1 for chord closure.
  1923.  */
  1924.     unsigned char *es, *esp;
  1925.     int octet_count;
  1926.  
  1927.     /* check to make sure the line is withing the scope of the picture
  1928.      * ie. the values you give for drawing the line are within
  1929.      * the values you created the picture with */
  1930.     if (!(cdImageBoundsSafe(im, sx,sy)) || !(cdImageBoundsSafe(im, ix,iy)) || !(cdImageBoundsSafe(im, ex, ey)))
  1931.         return 0;
  1932.  
  1933.     /* make sure that they close the arc either with pie (0) or chord (1) */
  1934.     if ((cl != 0) && (cl != 1))
  1935.         return 0;
  1936.  
  1937.     /* allocate sufficent space.  should be 32 bits * 6 to be safe */
  1938.     es = (unsigned char *) calloc(4*6, SIZEOF(unsigned char ) );
  1939.     if (!es) return 0; /* memory allocation failed */
  1940.     esp=es;
  1941.  
  1942.     /* their are seven 16 bit signed integers as attributes */
  1943.     if (!cdcomhead(es, 4, 14, 14)) return 0;
  1944.     es +=2; octet_count = 2;
  1945.  
  1946.     /* now we are ready for the parameter data */
  1947.     octet_count += cdAppShort(es, (short int) sx);
  1948.     es +=2;
  1949.     octet_count += cdAppShort(es, (short int) sy);
  1950.     es +=2;
  1951.     octet_count += cdAppShort(es, (short int) ix);
  1952.     es +=2;
  1953.     octet_count += cdAppShort(es, (short int) iy);
  1954.     es +=2;
  1955.     octet_count += cdAppShort(es, (short int) ex);
  1956.     es +=2;
  1957.     octet_count += cdAppShort(es, (short int) ey);
  1958.     es +=2;
  1959.     octet_count += cdAppShort(es, (short int) cl);
  1960.     es +=2;
  1961.  
  1962.         /* add it to the buffer */
  1963.         if (cdAddElem(im, esp, octet_count)) {
  1964.                 free(esp);
  1965.                 return 1;
  1966.         }
  1967.         else {
  1968.                 free(esp);
  1969.                 return 0;
  1970.         }
  1971.  
  1972.  
  1973. }
  1974.  
  1975. int cdEllipse(cdImagePtr im, int cx,int cy, int d1x,int d1y, int d2x,int d2y ) {
  1976. /* Graphic Primitive: Ellipse; Elem Class 4; Elem ID 17
  1977.  *
  1978.  * This function will draw an Ellipse using the current 
  1979.  * edge type, width, color, and visibility, and the current
  1980.  * fill style, color, and hatch
  1981.  */
  1982.     unsigned char *es, *esp;
  1983.     int octet_count;
  1984.  
  1985.     /* check to make sure the line is withing the scope of the picture
  1986.      * ie. the values you give for drawing the line are within
  1987.      * the values you created the picture with */
  1988.     if (!(cdImageBoundsSafe(im, cx,cy)) || !(cdImageBoundsSafe(im, d1x,d1y)) || !(cdImageBoundsSafe(im, d2x, d2y)))
  1989.         return 0;
  1990.  
  1991.     /* allocate sufficent space.  should be 32 bits * 4 to be safe */
  1992.     es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) );
  1993.     if (!es) return 0; /* memory allocation failed */
  1994.     esp=es;
  1995.  
  1996.     /* their are six 16 bit signed integers as attributes */
  1997.     if (!cdcomhead(es, 4, 17, 12)) return 0;
  1998.     es +=2; octet_count = 2;
  1999.  
  2000.     /* now we are ready for the parameter data */
  2001.     octet_count += cdAppShort(es, (short int) cx);
  2002.     es +=2;
  2003.     octet_count += cdAppShort(es, (short int) cy);
  2004.     es +=2;
  2005.     octet_count += cdAppShort(es, (short int) d1x);
  2006.     es +=2;
  2007.     octet_count += cdAppShort(es, (short int) d1y);
  2008.     es +=2;
  2009.     octet_count += cdAppShort(es, (short int) d2x);
  2010.     es +=2;
  2011.     octet_count += cdAppShort(es, (short int) d2y);
  2012.     es +=2;
  2013.  
  2014.         /* add it to the buffer */
  2015.         if (cdAddElem(im, esp, octet_count)) {
  2016.                 free(esp);
  2017.                 return 1;
  2018.         }
  2019.         else {
  2020.                 free(esp);
  2021.                 return 0;
  2022.         }
  2023.  
  2024.  
  2025. }
  2026.  
  2027. int cdPolygon(cdImagePtr im, cdPointPtr p, int n) {
  2028. /* Graphic Primitive: Polygon; Elem Class 4; Elem ID 7
  2029.  *
  2030.  * cdPointPtr is defined in cd.h, basically, it is two arrays of integers
  2031.  * p[m].x and p[m].y  containing the x and y values respectively.  n
  2032.  * is the number of points in this array (not the index of the last point,
  2033.  * which is n-1).  n must be at least 3 (otherwise
  2034.  * you really don't have much of a polygon, it is closer to a line.)
  2035.  *
  2036.  * This function will draw a Polygon using the current 
  2037.  * edge type, width, color, and visibility, and the current
  2038.  * fill style, color, and hatch
  2039.  */
  2040.     unsigned char *es, *esp;
  2041.     int octet_count;
  2042.     int x; /* counter */
  2043. /*     fprintf(stderr,"cdPolygon %d\n",n); */
  2044.  
  2045.     if (n < 3) return 0; /* it is either a point or a line */
  2046.  
  2047.     if (n < 8) {
  2048.     /* It fits in the short form of the command, lets us
  2049.      * add it right now, shall we? */
  2050.         /* allocate sufficent space. Should be 32 bits*10 to be safe */
  2051.         es = (unsigned char *) calloc(4*10,SIZEOF(unsigned char ));
  2052.         if (!es) return 0; /* memory allocation failed */
  2053.         esp=es;
  2054.  
  2055.  
  2056.         /* their are n*2 16 bit signed integers as attributes */
  2057.         if (!cdcomhead(es, 4, 7, (n*4))) return 0;
  2058.         es +=2; octet_count = 2;
  2059.  
  2060.     }
  2061.     else if (n < 8191) {
  2062.     /* there are more than 7 points in it, that sucks */
  2063.     /* gej, so basically, for this one, I set the header
  2064.      * to cdcomhead(es, 4, 7, 31) then write a function for the long
  2065.      * form that takes the first 15 bits of n and tags a 0 in front
  2066.      * of it and puts it in es, than I do the for loop all over again
  2067.      * that doesn't seem too hard.  But I will leave that for another
  2068.      * day.
  2069.  
  2070.      * keep in mind that if CDGROWLISTSIZE is smaller than n*4
  2071.      * (at most 32769) then things could fail in a most unsavory fashion.
  2072.      */
  2073.         /* allocate sufficent space.  32 bits*(n+1) to be safe */
  2074.         es = (unsigned char *) calloc(4*(n+1), SIZEOF(unsigned char ));
  2075.         if (!es) return 0; /* memory allocation failed */
  2076.         esp=es;
  2077.  
  2078.         if (!cdcomheadlong(es, 4, 7, (n*4))) return 0;
  2079.         es +=4; octet_count = 4;
  2080.     }
  2081.     else {
  2082.     /* there are more than 8191 points in it, I am not going to implement
  2083.      * that, if you want it that bad, do it yourself. */
  2084.         return 0;
  2085.     }
  2086.     
  2087.  
  2088.     for (x=0; x<n; x++) {
  2089.         /* now we are ready for the parameter data */
  2090.         es += cdAppShort(es, (short int) p->x);
  2091.         es += cdAppShort(es, (short int) p->y);
  2092.         octet_count += 4;
  2093.         p++;
  2094.     }
  2095.  
  2096.         /* add it to the buffer */
  2097.         if (cdAddElem(im, esp, octet_count)) {
  2098.                    free(esp);
  2099.                    return 1;
  2100.         }
  2101.         else {
  2102.                    free(esp);
  2103.                    return 0;
  2104.         }
  2105. }
  2106.  
  2107. int cdPolyLine(cdImagePtr im, cdPointPtr p, int n) {
  2108. /* Graphic Primitive: Polyline; Elem Class 4; Elem ID 1
  2109.  *
  2110.  * cdPointPtr is defined in cd.h, basically, it is two arrays of integers
  2111.  * p[m].x and p[m].y  containing the x and y values respectively.  n
  2112.  * is the number of points in this array (not the index of the last point,
  2113.  * which is n-1).  if n is 2, it is a regular line, like cdline
  2114.  *
  2115.  * This function will draw a Polyline using the current 
  2116.  * line type, width, color, and visibility, 
  2117.  */
  2118.     unsigned char *es, *esp;
  2119.     int octet_count;
  2120.     int x; /* counter */
  2121.  
  2122.     if (n < 2) return 0; /* it is a point */
  2123.  
  2124.     if (n < 8) {
  2125.     /* It fits in the short form of the command, lets us
  2126.      * add it right now, shall we? */
  2127.         /* allocate sufficent space. Should be 32 bits*10 to be safe */
  2128.         es = (unsigned char *) calloc(4*10,SIZEOF(unsigned char ));
  2129.         if (!es) return 0; /* memory allocation failed */
  2130.         esp=es;
  2131.  
  2132.  
  2133.         /* their are n*2 16 bit signed integers as attributes */
  2134.         if (!cdcomhead(es, 4, 1, (n*4))) return 0;
  2135.         es +=2; octet_count = 2;
  2136.  
  2137.     }
  2138.     else if (n < 8191) {
  2139.     /* there are more than 7 points in it, that sucks */
  2140.     /* gej, so basically, for this one, I set the header
  2141.      * using the long version cdcomheadlong(es, 4, 1, n*4)
  2142.  
  2143.      * keep in mind that if CDGROWLISTSIZE is smaller than n*4
  2144.      * (at most 32769) then the list may have to grow several times
  2145.      */
  2146.         /* allocate sufficent space.  32 bits*(n+1) to be safe */
  2147.         es = (unsigned char *) calloc(4*(n+1), SIZEOF(unsigned char ));
  2148.         if (!es) return 0; /* memory allocation failed */
  2149.         esp=es;
  2150.  
  2151.         if (!cdcomheadlong(es, 4, 1, (n*4))) return 0;
  2152.         es +=4; octet_count = 4;
  2153.     }
  2154.     else {
  2155.     /* there are more than 8191 points in it, I am not going to implement
  2156.      * that, if you want it that bad, do it yourself. */
  2157.         return 0;
  2158.     }
  2159.     
  2160.  
  2161.     for (x=0; x<n; x++) {
  2162.         /* now we are ready for the parameter data */
  2163.         es += cdAppShort(es, (short int) p->x);
  2164.         es += cdAppShort(es, (short int) p->y);
  2165.         octet_count += 4;
  2166.         p++;
  2167.     }
  2168.  
  2169.         /* add it to the buffer */
  2170.         if (cdAddElem(im, esp, octet_count)) {
  2171.                    free(esp);
  2172.                    return 1;
  2173.         }
  2174.         else {
  2175.                    free(esp);
  2176.                    return 0;
  2177.         }
  2178. }
  2179.  
  2180. int cdText(cdImagePtr im, int x, int y, const char *ts) {
  2181. /* Graphic Primitive: Text; Elem Class 4; Elem ID 4
  2182.  * add text to the picture.  Start it at the point (x,y)
  2183.  * this should be the lower left corner of where the text is
  2184.  * the parameters are point, enumerated(set to 1), string
  2185.  *
  2186.  * String encoding in CGM is a little strange.  After you have the other
  2187.  * parameter info, the first octet for the string is either 0..254 which
  2188.  * is the number of octets of string data, or 255 which signifies a long
  2189.  * string.  if it is 255 then the next 16 bits indicate the length of the
  2190.  * string.  the first bit (bit15) is 0 if this is the last part of the
  2191.  * string and 1 if another part follows it.  the next 15 bits  are in the
  2192.  * range 0..32767 and are the number of octets of string info following.
  2193.  * so the length stored in the command header is the whole enchelada.
  2194.  */
  2195.     int tslen, curly;
  2196.     unsigned char *es, *esp;
  2197.     int octet_count;
  2198.  
  2199.     /* check to make sure the Text is within the scope of the picture
  2200.      * actually, I am only checking the start of it
  2201.      */
  2202.     if (!(cdImageBoundsSafe(im, x, y)))
  2203.         return 0;
  2204.  
  2205.     /* allocate sufficent space.  should be tslen+ 32 bits * 4 to be safe */
  2206.     tslen = strlen(ts);
  2207.  
  2208.     /* if there are more than 32700 characters fail 
  2209.      * gej: this could go as high as 32767 I think, but lets 
  2210.      * cut it off at 32700 */
  2211.     if ((tslen > 32700) || (tslen < 0))return 0;
  2212.  
  2213.     es = (unsigned char *) calloc( ((4*4)+tslen), SIZEOF(unsigned char ) );
  2214.     if (!es) return 0; /* memory allocation failed */
  2215.     esp=es;
  2216.  
  2217.     if (!cdcomheadlong(es, 4, 4, 9+tslen)) return 0;
  2218.     es +=4; octet_count = 4;
  2219.  
  2220.     /* add the x position, the y position, then 1, which signifies
  2221.      * that this is all the text, there is none appended after it */
  2222.     es += cdAppShort(es, (short int) x);
  2223.     es += cdAppShort(es, (short int) y);
  2224.     es += cdAppShort(es, (short int) 1);
  2225.     octet_count += 6;
  2226.  
  2227.     /* now take care of the string information, for strings 254 bytes
  2228.      * or less, I could use a short one, but why bother, use the long
  2229.      * form for everything */
  2230.     es += cdAppByte(es, (short int) 255);
  2231.     es += cdAppShort(es, (short int) tslen);
  2232.     octet_count += 3;
  2233.     /* gej: I should set bit 15 to 0 because it is the final part of a 
  2234.      * string but I am not going to since I already checked that it was
  2235.      * a 16 number that was non-negative */
  2236.  
  2237.     while(*ts) {
  2238.         *es++ = (unsigned char) *ts++;
  2239.     }
  2240.     octet_count +=tslen;
  2241.     /* now if the octet_count is not divisible by 4 add null padding */
  2242.     curly = 4 - (octet_count % 4);
  2243.     if (curly % 4) {
  2244.         octet_count += curly;
  2245.         es += cdAppNull(es, curly);
  2246.     }
  2247.  
  2248.         /* add it to the buffer */
  2249.         if (cdAddElem(im, esp, octet_count)) {
  2250.                    free(esp);
  2251.                    return 1;
  2252.         }
  2253.         else {
  2254.                    free(esp);
  2255.                    return 0;
  2256.         }
  2257.  
  2258. }
  2259.  
  2260. int cdImageLine(cdImagePtr im, int x1, int y1, int x2, int y2, int color)
  2261. /* gej: this should be so much easier to do as a cgm 
  2262.  * This is in for compatibility with gd, if you don't need that, use
  2263.  * cdLine instead */
  2264. {
  2265.     int ltstate;
  2266.  
  2267.  
  2268.     /* save the linetype state */
  2269.     ltstate = im->ltype;
  2270.     /* set the attributes of the line */
  2271.     if (!cdSetLineAttrib(im, 1, -1, color)) return 0;
  2272.     if (!cdLine(im, x1, y1, x2, y2)) return 0;/* draw the line */
  2273.     /* restore the state If it fails, don't return an error, because
  2274.      * the line was still drawn */
  2275.     cdSetLineType(im, ltstate);
  2276.  
  2277.     return 1;
  2278. }
  2279.  
  2280. int cdImageDashedLine(cdImagePtr im, int x1, int y1, int x2, int y2, int color)
  2281. /* gej: this should be so much easier to do as a cgm 
  2282.  * in order to really get a dashed line you must call cdSetLineType first
  2283.  * This is in for compatibility with gd, if you don't need that, use
  2284.  * cdLine instead */
  2285. {
  2286.     /* set the attributes of the line */
  2287.     if (!cdSetLineAttrib(im, -1, -1, color)) return 0;
  2288.     /* generate the line */
  2289.     if (!cdLine(im, x1, y1, x2, y2)) return 0;
  2290.  
  2291.     /* everthing is A-OK */
  2292.     return 1;
  2293. }
  2294.  
  2295. int cdImageBoundsSafe(cdImagePtr im, int x, int y)
  2296. /* From gd library, see README file for copyright information */
  2297. /* gej: this should work unchanged */
  2298. {
  2299.     return (!(((y < 0) || (y >= im->sy)) ||
  2300.         ((x < 0) || (x >= im->sx))));
  2301. }
  2302.  
  2303.  
  2304. int cdImageRectangle(cdImagePtr im, int x1, int y1, int x2, int y2, int color)
  2305. /* Graphic Primitive: rectangle; Elem Class 4; Elem ID 11
  2306.  */
  2307.  
  2308. /* gej: but I think I will use the cgm rectangle */
  2309. {
  2310.     if(!cdImageLine(im, x1, y1, x2, y1, color)) return 0;
  2311.     if(!cdImageLine(im, x1, y2, x2, y2, color)) return 0;    
  2312.     if(!cdImageLine(im, x1, y1, x1, y2, color)) return 0;
  2313.     if(!cdImageLine(im, x2, y1, x2, y2, color)) return 0;
  2314.  
  2315.     return 1;
  2316. }
  2317.