From 43a13e2e02f2b92d912541ae3477b78f7ebd305c Mon Sep 17 00:00:00 2001 From: root <> Date: Sun, 8 Feb 2009 17:13:33 +0000 Subject: *** empty log message *** --- src/cd/Makefile | 52 ++ src/cd/cd.announce | 54 ++ src/cd/cd.c | 2372 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/cd/cd.h | 209 +++++ src/cd/cd.html | 1156 +++++++++++++++++++++++++ src/cd/cd1.2.lsm | 11 + src/cd/cdmulti.c | 98 +++ src/cd/cdsimple.c | 109 +++ src/cd/cdtest.c | 425 +++++++++ src/cd/cdtext.c | 135 +++ src/cd/color16.c | 186 ++++ src/cd/defines.h | 55 ++ src/cd/makefile.bor | 51 ++ src/cd/readme | 52 ++ 14 files changed, 4965 insertions(+) create mode 100644 src/cd/Makefile create mode 100644 src/cd/cd.announce create mode 100644 src/cd/cd.c create mode 100644 src/cd/cd.h create mode 100644 src/cd/cd.html create mode 100644 src/cd/cd1.2.lsm create mode 100644 src/cd/cdmulti.c create mode 100644 src/cd/cdsimple.c create mode 100644 src/cd/cdtest.c create mode 100644 src/cd/cdtext.c create mode 100644 src/cd/color16.c create mode 100644 src/cd/defines.h create mode 100644 src/cd/makefile.bor create mode 100644 src/cd/readme diff --git a/src/cd/Makefile b/src/cd/Makefile new file mode 100644 index 0000000..8e77306 --- /dev/null +++ b/src/cd/Makefile @@ -0,0 +1,52 @@ +# Makefile for CGM Draw by G. Edward Johnson +# You may need to modify this makefile + +CC=cc +AR=ar +# CFLAGS= +#CFLAGS= -O -xF -Wa,-cg92 +CFALGS=-O +LIBS=-L./ -lcd + +all: libcd.a cdtest color16 cdsimple cdtext cdmulti + +libcd.a: cd.h defines.h cd.o + rm -f libcd.a + $(AR) rc libcd.a cd.o + +cd.o: cd.c cd.h defines.h + $(CC) $(CFLAGS) -c cd.c + +testmain.o: testmain.c cd.h defines.h + $(CC) $(CFLAGS) -c testmain.c + +color16.o: color16.c cd.h defines.h + $(CC) $(CFLAGS) -c color16.c + +cdsimple.o: cdsimple.c cd.h defines.h + $(CC) $(CFLAGS) -c cdsimple.c + +cdtext.o: cdtext.c cd.h defines.h + $(CC) $(CFLAGS) -c cdtext.c + +cdmulti.o: cdmulti.c cd.h defines.h + $(CC) $(CFLAGS) -c cdmulti.c + +cdsimple: cdsimple.o libcd.a + $(CC) -o cdsimple cdsimple.o $(LIBS) + +color16: color16.o libcd.a + $(CC) -o color16 color16.o $(LIBS) + +cdtest: cdtest.o libcd.a + $(CC) -o cdtest cdtest.o $(LIBS) + +cdtext: cdtext.o libcd.a + $(CC) -o cdtext cdtext.o $(LIBS) + +cdmulti: cdmulti.o libcd.a + $(CC) -o cdmulti cdmulti.o $(LIBS) + + +clean: + rm -f *.o *.a cdtest color16 cdsimple cdtext cdmulti diff --git a/src/cd/cd.announce b/src/cd/cd.announce new file mode 100644 index 0000000..e19a0ef --- /dev/null +++ b/src/cd/cd.announce @@ -0,0 +1,54 @@ + + +Announcing the release of CGM Draw 1.2. + +CGM Draw is a freely available library for generating CGM files from a +C program. It has been tested on Solaris, Ultrix, Linux, IRIX, and DOS. +CGM (Computer Graphics Metafile) is a vector graphics format that can be +read by many popular packages. With CGM Draw your code can quickly +draw images complete with lines, arcs, rectangles, polygons, and text. +CGM Draw is ideal for creating CGM files on the fly when you have +a rapidly changing data set (such as in response to database queries.) + + +Documentation for cd is included with the package, and is available from +http://speckle.ncsl.nist.gov/~lorax/cgm/cd.html +General information about CGM is available many places on the web, including +http://speckle.ncsl.nist.gov/~lsr/cgm.htm +This distribution may be retrieved via ftp from +zing.ncsl.nist.gov in the directory "cgm" It will have the +name cd followed by the version number. +The current version is 1.2 and is at: +ftp://zing.ncsl.nist.gov/cgm/cd1.2.tar.gz + + +Whats new in this version: +- New Text attributes for the direction and rotation of text +- Multiple pictures can be put in a single cgm file +- More example programs. + + +What is CGM: +CGM is a widely used method for representing 2D vector +pictures. Many industry users have decided to use CGM as the means of +representing, storing, and interchanging pictures in all their documentation +(e.g., Air Transport Association will use CGM to represent illustrations, US +Petroleum industry has also adopted it). +CGM is already and established, open standard. In 1987 +ISO approved the first version as an international standard, and the +current version (which extends the original) was approved in 1992 (ISO +8632.) Many programs are already capable of creating CGM files. Major +illustration packages already can save their files in the CGM format +(CorelDraw is one example) and many word processing programs (WordPerfect +and Word) can include CGM files in their documents. + + +What types of pictures is CGM suited for: +CGM is ideally suited for pictures with geometric shapes, line drawings, +and text. Here are some particular applications that CGM would do well +with: + Charts and Graphs--For instance charts of recent stock market data, or +graphs of web server usage. + Technical illustrations--Diagrams for products or engineering drawings. +CGM pictures can be zoomed in on to show small details. + General illustrations--Such as those you see in books or comic strips. diff --git a/src/cd/cd.c b/src/cd/cd.c new file mode 100644 index 0000000..97656f9 --- /dev/null +++ b/src/cd/cd.c @@ -0,0 +1,2372 @@ + +/* cd.c main file for cgmdraw module. + + Written by G. Edward Johnson + Date: April 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + + Portions of this package are from the gd package written by + Thomas Boutell and are copyright 1994, 1995, Quest Protein + Database Center, Cold Spring Harbor Labs. They are marked in the + source code. + +*/ + + +#include +#include +#include +#include +#include +#include "defines.h" +#include "cd.h" + + +cdImagePtr cdImageCreate(int sx, int sy) +{ + cdImagePtr im; + im = (cdImage *) calloc(SIZEOF(cdImage), 1); + if (!im) return 0; /* memory allocation failed */ + /* elemlist is set to some number, when it is full, make it bigger */ + im->elemlist = (unsigned char *) calloc(CDSTARTLISTSIZE, SIZEOF(unsigned char ) ); + if (!im->elemlist) return 0; /* memory allocation failed */ + im->sx = sx; + im->sy = sy; + im->colorsTotal = 0; + /* you can have multiple pictures in a file, keep track of + * which one you are on */ + im->picnum = 10; + /* set line_width, line_height, line_color to the defaults */ + /*gej: I should change these when I figure out what the defaults are */ + im->ltype = CDLTYPE; + im->lwidth = CDLWIDTH; + im->lcolor = CDLCOLOR; + /* interior_style, fill_color, hatch_index */ + im->shapestyle = CDSHAPESTYLE; + im->shapecolor = CDSHAPECOLOR; + im->shapehatch = CDSHAPEHATCH; + /* edge_type, edge_width, edge_color, edge_visibility */ + im->edgetype = CDEDGETYPE; + im->edgecolor = CDEDGECOLOR; + im->edgewidth = CDEDGEWIDTH; + im->edgevis = CDEDGEVIS; + /* text_color, text_height, text_font */ + im->textcolor = CDTEXTCOLOR; + im->textheight = CDTEXTHEIGHT; + im->textfont = CDTEXTFONT; + im->textpath = CDTEXTPATH; + /* the next three are used for maintaining the element list + * don't change these ever */ + im->bytestoend = CDSTARTLISTSIZE; + im->listlen = CDSTARTLISTSIZE; + im->curelemlist = im->elemlist; + + cdCgmHeader(im); + return im; + +} + +static int cdAppNull(unsigned char *es, int x) { +/* put x nulls in the string. + * return value is number of octets added (1) */ + int y; + + for(y=0; y> 8; + *es = (unsigned char) temp & 0377; + es++; + *es = (unsigned char) addme & 0377; + return 2; +} + +/* static int cdAppWord(unsigned char *es, int addme){ */ +/* Append an word to es + * Return value is number of octets added + * For internal cd functions only, do not call! + */ +/* + int temp; + temp = addme >> 24; + *es = (unsigned char) temp & 0377; + es++; + temp = addme >> 16; + *es = (unsigned char) temp & 0377; + es++; + temp = addme >> 8; + *es = (unsigned char) temp & 0377; + es++; + *es = (unsigned char) addme & 0377; + es++; + return 4; +} +*/ + +static int cdcomhead(unsigned char *es, int elemclass, int id, int len) { +/* sets the command header in the first two bytes of string es + * element class is in bits 15-12 + * element id is in bits 11-5 + * parameter list length is in bits 4-0 + */ + int temp; + + if (!es) return 0; /* the string must be allocated first */ + + /* set the element class */ + *es = (unsigned char) elemclass << 4; + /* set the element id */ + temp = 0177 & id ; + temp = temp >> 3; + *es = *es | temp; + es++; + id = id << 5; + *es = (unsigned char) id; + *es = *es | (unsigned char) ( 037 & len ); + + return 1; +} + +static int cdcomheadlong(unsigned char *es, int elemclass, int id, int len) { +/* sets the command header for the long form. + * first 16 bits: + * element class is in bits 15-12 + * element id is in bits 11-5 + * parameter list length is in bits 4-0 = 31 + * second 16 bits: + * bit 15 = 0 (for last partition) + * bit 14-0 param list len + */ + + /* I'm lazy, call cdcomhead to set the first two bytes */ + if (!cdcomhead(es, elemclass, id, 31)) return 0; + es += 2; + + /* now set the second two bytes */ + cdAppShort(es, (short int) len); + *es = *es & 0177; /* make bit 15 = 0 */ + es += 2; + + return 1; +} +static int cdcomheadlongp(unsigned char *es, int elemclass, int id) { +/* sets the command header for the long form. + * first 16 bits: + * element class is in bits 15-12 + * element id is in bits 11-5 + * parameter list length is in bits 4-0 = 31 + * second 16 bits: + * bit 15 = 0 (for last partition) + * bit 14-0 param list len + */ + + /* I'm lazy, call cdcomhead to set the first two bytes */ + if (!cdcomhead(es, elemclass, id, 31)) return 0; + es += 2; + + return 1; +} +static int cdcomheadlongc(unsigned char *es, int part, int len) { +/* sets the command header for the long form. + * second 16 bits: + * bit 15 = 0 (for last partition) + * bit 14-0 param list len + */ + + cdAppShort(es, (short int) len); + *es = *es & 0177; /* make bit 15 = 0 */ + if (part) *es=(*es) | 128; + es += 2; + + return 1; +} + +static int cdAddElem(cdImagePtr im, unsigned char *es, int octet_count) +/* adds a string, which is a CGM element to the elemlist. + * This function is called by other functions in this library and + * should NOT be called by users of the library + * For internal cd functions only, do not call! + */ +{ + unsigned char *newlist; /* in case memory allocation fails */ + int x; /* counter */ + + while ((octet_count + 1) >= im->bytestoend) { + /* not enough space, must grow elemlist */ + im->listlen = im->listlen + CDGROWLISTSIZE; + newlist = (unsigned char *) realloc(im->elemlist, SIZEOF(unsigned char ) * im->listlen); + if (newlist) { + /* successfully allocated memory */ + im->elemlist = newlist; + im->bytestoend = im->bytestoend + CDGROWLISTSIZE; + im->curelemlist = im->elemlist + (im->listlen - im->bytestoend); + } + else { + /* memory allocation failed, save yurself */ + im->listlen = im->listlen - CDGROWLISTSIZE; + return 0; + } + } + + /* ok, if we get to here, there is enough space, so add it. */ + for (x=0; x < octet_count; x++) { + *im->curelemlist = (unsigned char) *es; + im->curelemlist++; + es++; + } + im->bytestoend = im->bytestoend - octet_count; + return 1; + +} + +int cdCgmHeader(cdImagePtr im) { +/* add the cgm header to the imagepointer's element list + * do it all in a string than call cdAddElem on it + * For internal cd functions only, do not call! + */ + unsigned char *headerp; + unsigned char *head; + unsigned char *buf, *buf2; + int octet_count=0; + int blen; /* length of buf */ + int curly; + + headerp = (unsigned char *) calloc(1024, SIZEOF(unsigned char )); + if (!headerp) return 0; /* memory allocation failed */ + head=headerp; + + /*** Attribute: BegMF; Elem Class 0; Elem ID 1 */ + buf = (unsigned char *) "cd: CgmDraw Library"; + blen = strlen( (char *) buf); + cdcomhead(head, 0, 1, blen+1); + head += 2; + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + octet_count += (blen + 3); + curly = 4 - (octet_count % 4); + if (curly % 4) { + octet_count += curly; + head += cdAppNull(head, curly); + } + + /*** Attribute: MFVersion; Elem Class 1; Elem ID 1 */ + cdcomhead(head, 1, 1, 2); + head += 2; + head += cdAppShort(head, (short int) 1); + octet_count += 4; + + /*** Attribute: MFDesc; Elem Class 1; Elem ID 2 */ + buf = (unsigned char *) "'ProfileId: Model-Profile''ProfileEd:1''ColourClass:colour''Source:Nist CGMDraw 1.2''Date: 1996-06-28'"; + blen = strlen( (char *) buf); + cdcomheadlong(head, 1, 2, blen+1); + head += 4; + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + octet_count += (blen + 5); + curly = 4 - (octet_count % 4); + if (curly % 4) { + octet_count += curly; + head += cdAppNull(head, curly); + } + + /*** Attribute: ColrPrec; Elem Class 1; Elem ID 7 */ + cdcomhead(head, 1, 7, 2); + head += 2; + head += cdAppShort(head, (short int) 8); + octet_count += 4; + + /*** Attribute: ColrIndexPrec; Elem Class 1; Elem ID 8 */ + cdcomhead(head, 1, 8, 2); + head += 2; + head += cdAppShort(head, (short int) 8); + octet_count += 4; + + /*** Attribute: MaxColrIndex; Elem Class 1; Elem ID 9 */ + cdcomhead(head, 1, 9, 1); + head += 2; + head += cdAppByte(head, (short int) 255); + octet_count += 4; head++; + + /*** Attribute: MFElemList; Elem Class 1; Elem ID 11 */ + /* shorthand here. 1 means 1 element specified, (-1,1) + * means drawing-plus-control set */ + cdcomhead(head, 1, 11, 6); + head += 2; + head += cdAppShort(head, (short int) 1); + head += cdAppShort(head, (short int) -1); + head += cdAppShort(head, (short int) 1); + octet_count += 8; + + /*** Attribute: FontList; Elem Class 1; Elem ID 13 */ + cdcomheadlong(head, 1, 13, 112); + head +=4; + buf = (unsigned char *) "Times"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + buf = (unsigned char *) "Times Bold"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + buf = (unsigned char *) "Times Italic"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + buf = (unsigned char *) "Times Bold Italic"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + buf = (unsigned char *) "Helvetica"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + buf = (unsigned char *) "Helvetica Bold"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + buf = (unsigned char *) "Helvetica Italic"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + buf = (unsigned char *) "Helvetica Bold Italic"; + blen = strlen( (char *) buf); + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + octet_count += (4 + 112); + curly = 4 - (octet_count % 4); + if (curly % 4) { + octet_count += curly; + head += cdAppNull(head, curly); + } + + + if (cdAddElem(im, headerp, octet_count)) { + free(headerp); + headerp = 0; + } + else { + free(headerp); + return 0; + } + + if (cdCgmPic(im, 0)) { + return 1; + } + else { + return 0; + } +} + + +int cdCgmPic(cdImagePtr im, int sticky) { +/* Start the picture. if the sticky bit is set, set and use the defaults + * of the previous picture. Otherwise, reset all defaults. + * Gej: Right now, will only work if the sticky bit is not set (is 0) + */ + unsigned char *headerp; + unsigned char *head; + unsigned char *buf, *buf2; + char *tb; + int octet_count=0; + int blen; /* length of buf */ + + /* increment the picture number */ + im->picnum++; + tb = (char *) calloc(4*4, SIZEOF(char) ); + headerp = (unsigned char *) calloc(1024, SIZEOF(unsigned char )); + if (!headerp) return 0; /* memory allocation failed */ + head=headerp; + + + /*** Attribute: BegPic; Elem Class 0; Elem ID 3 */ + sprintf(tb, "picture %d", im->picnum); + buf = (unsigned char*) tb; + /* buf = (unsigned char *) "picture 1"; */ + blen = strlen( (char *) buf); + cdcomhead(head, 0, 3, blen+1); + head += 2; + head += cdAppByte(head, (short int) blen); + buf2 = buf; + while (*buf2) { + *head++ = *buf2++; + } + octet_count += (blen + 3); + if (!(blen % 2)) { + octet_count++; + head += cdAppNull(head, 1); + } + if (octet_count % 4) { + octet_count +=2; + head += cdAppNull(head, 2); + } + + /*** Attribute: ColrMode; Elem Class 2; Elem ID 2 */ + cdcomhead(head, 2, 2, 2); + head += 2; + head += cdAppShort(head, (short int) 0); + octet_count += 4; + + /*** Attribute: VDCExt; Elem Class 2; Elem ID 6 */ + cdcomhead(head, 2, 6, 8); + head += 2; + head += cdAppShort(head, (short int) 0); + head += cdAppShort(head, (short int) 0); + head += cdAppShort(head, (short int) im->sx); + head += cdAppShort(head, (short int) im->sy); + octet_count += 10; + + /*** Attribute: ColrPrec; Elem Class 0; Elem ID 4 */ + cdcomhead(head, 0, 4, 0); + head += 2; + octet_count += 2; + + if (sticky) { + /* gej: were screwed. This isn't implemented yet */ + free(headerp); + return 0; + } + else { + /* reset all the defaults */ + /* set line_width, line_height, line_color to the defaults */ + im->ltype = CDLTYPE; + im->lwidth = CDLWIDTH; + im->lcolor = CDLCOLOR; + /* interior_style, fill_color, hatch_index */ + im->shapestyle = CDSHAPESTYLE; + im->shapecolor = CDSHAPECOLOR; + im->shapehatch = CDSHAPEHATCH; + /* edge_type, edge_width, edge_color, edge_visibility */ + im->edgetype = CDEDGETYPE; + im->edgecolor = CDEDGECOLOR; + im->edgewidth = CDEDGEWIDTH; + im->edgevis = CDEDGEVIS; + /* text_color, text_height, text_font */ + im->textcolor = CDTEXTCOLOR; + im->textheight = CDTEXTHEIGHT; + im->textfont = CDTEXTFONT; + im->textpath = CDTEXTPATH; + /* Nuke the color table if there is one */ + cdImageColorClear(im); + } + + + if (cdAddElem(im, headerp, octet_count)) { + free(headerp); + return 1; + } + else { + free(headerp); + return 0; + } + +} + +int cdCgmNewPic(cdImagePtr im, int sticky) +/* The CGM standard allows multiple images in a single file. This function + * will close the current picture, then open a new one. + * if sticky is 0 then all attributes will be reset to the defaults + * if sticky is 1 then all attributes will be inherited from the prevous + * picture. This is currently not implemented, be sure to set sticky to + * 0. + */ +{ + unsigned char *es, *esp; + int octet_count=0; + + esp = (unsigned char *) calloc(1024, SIZEOF(unsigned char )); + if (!esp) return 0; /* memory allocation failed */ + es=esp; + + /* Attribute: End Picture; Elem Class 0; Elem ID 5; Length 0 */ + cdcomhead(es, 0, 5, 0); + octet_count += 2; + + + if (cdAddElem(im, esp, octet_count)) { + free(esp); + } + else { + free(esp); + return 0; + } + + /* now start the new picture */ + return(cdCgmPic(im, sticky)); + + +} + +int cdImageCgm(cdImagePtr im, FILE *out) +/* Gej: Write the image to file *out, which must be open already + * does not close the file */ +{ + int x; /* counter */ + int used; /* number of bytes used in the list */ + unsigned char *efile, *efilep; /* end of file information */ + efile = (unsigned char *) calloc(4*4,SIZEOF(unsigned char )); + if (!efile) return 0; /* memory allocation failed */ + efilep=efile; + /* Attribute: End Picture; Elem Class 0; Elem ID 5 */ + *efilep = '\0'; + efilep++; + *efilep = '\240'; /* set Elem ID */ + efilep++; + /* Attribute: End Metafile; Elem Class 0; Elem ID 2 */ + *efilep = '\0'; + efilep++; + *efilep = '\100'; /* set Elem ID */ + + + if (cdAddElem(im, efile, 4)) { + free(efile); + efile = 0; + efilep = 0; + } + else { + free(efile); + return 0; + } + + /* now output the string, one byte at a time */ + used = im->listlen - im->bytestoend; + for (x=0;x < used; x++) { + putc((unsigned char) im->elemlist[x], out); + } + + return 1; + +} + + +int cdSetLineType(cdImagePtr im, int lntype) { +/* Attribute: Line Type; Elem Class 5; Elem ID 2 + * Set the line type. Possible values are: + * 1=solid, 2=dash, 3=dot, 4=dash-dot, 5=dash-dot-dot + * Even though new ones can be defined, I am limiting lntype to these values + * If you really need more, you can make the proper changes. + */ + unsigned char *es, *esp; + int octet_count; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (lntype == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (lntype == im->ltype) + return 1; + + /* Make sure that lntype is between 1 and 5 */ + if ((lntype < 1) || (lntype > 5)) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if (!cdcomhead(es, 5, 2, 2)) return 0; + es += 2; + /* set Param_List_Len to 2 (signed int at index precision) */ + + /* add in the value of lntype */ + es += cdAppShort(es, (short int) lntype); + + octet_count = 4; /* we just know this */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->ltype = (short int) lntype; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdSetLineWidth(cdImagePtr im, int lnwidth) { +/* Attribute: Line Width; Elem Class 5; Elem ID 3 + * sets the line width. with an image of height X with line width 1 + * the displayed width will be 1/X%. as an example, if you image is + * x=5, y=10, and you set line width = 1, and draw a vertical line, the + * resulting line will cover 20% of horizontal area. + */ + unsigned char *es, *esp; + int octet_count; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (lnwidth == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (lnwidth == im->lwidth) + return 1; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + + octet_count = 2; + if (!cdcomhead(es, 5, 3, 4)) return 0; + es += 2; + /*gej: line width is 32 bit floating point number, 16 bits before the + * decimal, 16 bits after. */ + + es += cdAppShort(es, (short int) lnwidth); + + /* the next two (after decimal point) will always be zero */ + es += cdAppNull(es, 2); + + octet_count += 4; + + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->lwidth = lnwidth; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdSetLineColor(cdImagePtr im, int lncolor) { +/* Attribute: Line Colour; Elem Class 5; Elem ID 4 + * Sets the line color. lncolor should be an index into the color + * table that you have previously allocated. + */ + unsigned char *es, *esp; + int octet_count; + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (lncolor == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (lncolor == im->lcolor) + return 1; + + /* Make sure the color they want to use has been allocated. + * also, that color must be non-negative */ + if ((lncolor >= im->colorsTotal ) || (lncolor < 0)) + return 0; /* you must allocate a color before you use it */ + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + + if (!cdcomhead(es, 5, 4, 1)) return 0; + es += 2; + + *es = 0377 & lncolor; /* mask off last 8 bits and put in es */ + es++; + + es += cdAppNull(es, 1); + + octet_count = 4; /* we just know this; 2 octets of header, + * 1 octet of data, 1 octet of null data */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->lcolor = (short int) lncolor; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdSetFillStyle(cdImagePtr im, int instyle) { +/* set the style of the interior of filled area elements. + * Attribute: Interior Style; Elem Class 5; Elem ID 22 + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Interior Style: (integers 0-6, corresponding to: hollow, solid, + * [not pattern], hatch, empty, [not geometric pattern], + * interpolated.) + * attribute is 16 bit signed int + */ + unsigned char *es, *esp; + int octet_count; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (instyle == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (instyle == im->shapestyle) + return 1; + + /* Make sure that lnhatch is between 0 and 6, but not + * 2, 5, or 6 */ + if ((instyle < 0) || (instyle > 4) || (instyle == 2)) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + /* set the header to Class 5, ID 22, Length 2 */ + if (!cdcomhead(es, 5, 22, 2)) return 0; + es += 2; + + /* add in the value of inhatch */ + es += cdAppShort(es, (short int) instyle); + + octet_count = 4; /* we just know this */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->shapestyle = (short int) instyle; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdSetFillColor(cdImagePtr im, int incolor) { +/* set the color of the interior of filled area elements + * Attribute: Fill Colour; Elem Class 5; Elem ID 23 + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Fill Colour: (index into the color table) + */ + unsigned char *es, *esp; + int octet_count; + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (incolor == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (incolor == im->shapecolor) + return 1; + + /* Make sure the color they want to use has been allocated. + * also, that color must be non-negative */ + if ((incolor >= im->colorsTotal ) || (incolor < 0)) + return 0; /* you must allocate a color before you use it */ + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if (!cdcomhead(es, 5, 23, 1)) return 0; + es += 2; + + *es = 0377 & incolor; /* mask off last 8 bits and put in es */ + es++; + es += cdAppNull(es, 1); + + octet_count = 4; /* we just know this; 2 octets of header, + * 1 octet of data, 1 octet of null data */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->shapecolor = (short int) incolor; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + + +} + +int cdSetFillHatch(cdImagePtr im, int inhatch) { +/* Set the hatch pattern for the interior of filled-area elements + * the fill style must be set to hatch for this to have an effect. + * Attribute: Hatch Index; Elem Class 5; Elem ID 24 + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Hatch Index: (integers 1-6, corresponding to: horizontal lines, + * vertical lines, pos. slope parallel lines, + * neg. slope parallel lines, horizontal/vertical + * crosshatch, positive/negative slope crosshatch) + */ + + unsigned char *es, *esp; + int octet_count, temp; + + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (inhatch == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (inhatch == im->shapehatch) + return 1; + + /* Make sure that lnhatch is between 1 and 6 */ + if ((inhatch < 1) || (inhatch > 6)) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + /* set the command header to class 5, id 24, length 2 */ + if (!cdcomhead (es, 5, 24, 2)) return 0; + es += 2; + + /* add in the value of inhatch */ + temp = inhatch >> 8; + *es = *es | (temp & 0377); + es++; + *es = *es | (inhatch & 0377); + es++; + + octet_count = 4; /* we just know this */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->shapehatch = (short int) inhatch; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdSetEdgeType(cdImagePtr im, int edtype) { +/* set the type of the edge of filled-area elements. + * Attribute: Edge Type; Elem Class 5; Elem ID 27 + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Edge Type (integers 1-5, corresponding to: solid, dash, dot, + * dash-dot, dash-dot-dot. These are the same as those used + * for line type.) + * In Part 3 of the standard (Binary Encoding) on page 47 it says that + * edge type is integer. This is incorrect. Edge type is Index, just + * like line type. + * Even though new ones can be defined, I am limiting lntype to these values + * If you really need more, you can make the proper changes. + */ + unsigned char *es, *esp; + int octet_count; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (edtype == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (edtype == im->edgetype) + return 1; + + /* Make sure that lntype is between 1 and 5 */ + if ((edtype < 1) || (edtype > 5)) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if(!cdcomhead(es, 5, 27, 2)) return 0; + es += 2; + + /* add in the value of edtype */ + es += cdAppShort(es, (short int) edtype); + + octet_count = 4; /* we just know this */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->edgetype = (short int) edtype; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdSetEdgeWidth(cdImagePtr im, int edwidth) { +/* Set the width of the edge of filled-area elements. + * Attribute: Edge Width; Elem Class 5; Elem ID 28 + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Edge Width (should be the same as line width) + */ + unsigned char *es, *esp; + int octet_count, temp; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (edwidth == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (edwidth == im->edgewidth) + return 1; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + octet_count = 2; + if (!cdcomhead(es, 5, 28, 4)) return 0; + es += 2; + + /*gej: edge width is 32 bit floating point number, 16 bits before the + * decimal, 16 bits after. */ + es++; octet_count++; + temp = edwidth >> 8; + *es = *es | (temp & 0377); + es++; octet_count++; + *es = *es | (edwidth & 0377); + /* the next two (after decimal point) will always be zero */ + es += cdAppNull(es, 2); + octet_count+=2; + + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->edgewidth = edwidth; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + + +} + +int cdSetEdgeColor(cdImagePtr im, int edcolor) { +/* Set the color of the edge of filled-area elements. + * Attribute: Edge Color; Elem Class 5; Elem ID 29 + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Edge Colour (index into the color table) + */ + unsigned char *es, *esp; + int octet_count; + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (edcolor == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (edcolor == im->edgecolor) + return 1; + + /* Make sure the color they want to use has been allocated. + * also, that color must be non-negative */ + if ((edcolor >= im->colorsTotal ) || (edcolor < 0)) + return 0; /* you must allocate a color before you use it */ + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + if (!cdcomhead(es, 5, 29, 1)) return 0; + es += 2; + + *es = 0377 & edcolor; /* mask off last 8 bits and put in es */ + es++; + es += cdAppNull(es, 1); + + octet_count = 4; /* we just know this; 2 octets of header, + * 1 octet of data, 1 octet of null data */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->edgecolor = (short int) edcolor; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + + +} + +int cdSetEdgeVis(cdImagePtr im, int edvis) { +/* Set the visibility of the edge of filled-area elements. + * Attribute: Edge Visibility; Elem Class 5; Elem ID 30 + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Edge Visibility (integer 0 or 1, corresponding to: Off, On) + * Attribute is 16 bit signed int. + */ + unsigned char *es, *esp; + int octet_count, temp; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (edvis == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (edvis == im->edgevis) + return 1; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if (!cdcomhead(es, 5, 30, 2)) return 0; + es +=2; octet_count = 2; + temp = edvis >> 8; + *es = *es | (temp & 0377); + es++; + *es = *es | (edvis & 0377); + es++; + octet_count += 2; + + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->edgevis = (short int) edvis; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdSetTextFont(cdImagePtr im, int font) { +/* Attribute: Text Font Index; Elem Class 5; Elem ID 10 + * font is an index into the font table. it can have one of the following + * values: + * 1 Times + * 2 Times Bold + * 3 Times Italic + * 4 Times Bold Italic + * 5 Helvetica + * 6 Helvetica Bold + * 7 Helvetica Italic + * 8 Helvetica Bold Italic + */ + unsigned char *es, *esp; + int octet_count; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (font == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (font == im->textfont) + return 1; + + /* Make sure that font is between 1 and 8 */ + if ((font < 1) || (font > 8)) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if(!cdcomhead(es, 5, 10, 2)) return 0; + es += 2; + + es += cdAppShort(es, (short int) font); + + octet_count = 4; /* we just know this */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->textfont = (short int) font; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdSetTextColor(cdImagePtr im, int color) { +/* Attribute: Text Colour ; Elem Class 5; Elem ID 14 + * set the forground color of text + */ + unsigned char *es, *esp; + int octet_count; + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (color == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (color == im->textcolor) + return 1; + + /* Make sure the color they want to use has been allocated. + * also, that color must be non-negative */ + if ((color >= im->colorsTotal ) || (color < 0)) + return 0; /* you must allocate a color before you use it */ + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if(!cdcomhead(es, 5, 14, 1)) return 0; + es += 2; + + *es = 0377 & color; /* mask off last 8 bits and put in es */ + es++; + + octet_count = 4; /* we just know this; 2 octets of header, + * 1 octet of data, 1 octet of null data */ + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->textcolor = (short int) color; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdSetTextHeight(cdImagePtr im, int height) { +/* Attribute: Character Height; Elem Class 5; Elem ID 15 + * the height is in the same units as line width + */ + unsigned char *es, *esp; + int octet_count; + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (height == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (height == im->textheight) + return 1; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if(!cdcomhead(es, 5, 15, 2)) return 0; + octet_count = 2; es += 2; + + es += cdAppShort(es, height); + octet_count += 2; + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->textheight = height; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdSetTextPath(cdImagePtr im, int tpath) { +/* Attribute: Text Path; Elem Class 5; Elem ID 17 + * Is one of: + * 0 right -- Means the direction of the character base vector + * 1 left -- means 180 degrees from the character base vector + * 2 up -- means the direction of the character up vector + * 3 down -- means 180 degrees from the character up vector + */ + unsigned char *es, *esp; + int octet_count; + + /* First check and see if the user doesn't want any changes, + * if so, just return success */ + if (tpath == -1) + return 1; + + /* Check and see if the value it is being set to is the current + * value, if so, don't make any changes, just return 1 */ + if (tpath == im->textpath) + return 1; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + octet_count = 0; + + if (!cdcomhead(es, 5, 17, 2)) return 0; + es +=2; octet_count = 2; + + es += cdAppShort(es, (short int) tpath); + octet_count += 2; + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + im->textpath = (short int) tpath; + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdSetTextOrient(cdImagePtr im, int xup, int yup, int xbase, int ybase) { +/* Attribute: Character Orientation; Elem Class 5; Elem ID 16 + * (xbase,ybase) is the run and the rise of the line that the text is + * written along. For regular text at an angle, set xup = -ybase + * and yup = xbase. Setting it to something different will result in + * skewed text (which may be what you want.) Text written from bottom to + * top at a 90 degree angle would have the following parameters + * xup=-1, yup=0, xbase=0, ybase=1 + * + * This function adds the Orientation to the metafile every time. + * It does not follow the normal -1 for no change, although if you + * put in the same numbers it won't re-add it to the meta file. + */ + unsigned char *es, *esp; + int octet_count; + + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + octet_count = 0; + + if (!cdcomhead(es, 5, 16, 8)) return 0; + es +=2; octet_count += 2; + + /* In the metafile it is a 16 bit signed integer */ + /* add xup */ + es += cdAppShort(es, (short int) xup); + octet_count += 2; + /* add the rest */ + es += cdAppShort(es, (short int) yup); + octet_count += 2; + es += cdAppShort(es, (short int) xbase); + octet_count += 2; + es += cdAppShort(es, (short int) ybase); + octet_count += 2; + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdSetLineAttrib(cdImagePtr im, int lntype, int lnwidth, int lncolor) { +/* Spits out the attributes of lines. These attributes stay in effect + * until changed, so you don't have to output them every time. + */ + + if (!cdSetLineType(im, lntype)) return 0; + if (!cdSetLineWidth(im, lnwidth)) return 0; + if (!cdSetLineColor(im, lncolor)) return 0; + + return 1; + +} + +int cdSetShapeFillAttrib(cdImagePtr im, int instyle, int incolor, int inhatch) { +/* Spits out the attributes for the interior of filled-area elements. + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Set the following attributes: + * Interior Style: (integers 0-6, corresponding to: hollow, solid, + * [not pattern], hatch, empty, [not geometric pattern], + * interpolated.) + * Fill Colour: (index into the color table) + * Hatch Index: (integers 1-6, corresponding to: horizontal lines, + * vertical lines, pos. slope parallel lines, + * neg. slope parallel lines, horizontal/vertical + * crosshatch, positive/negative slope crosshatch) + */ + if (!cdSetFillStyle(im, instyle)) return 0; + if (!cdSetFillColor(im, incolor)) return 0; + if (!cdSetFillHatch(im, inhatch)) return 0; + + return 1; +} + +int cdSetShapeEdgeAttrib(cdImagePtr im, int edtype, int edwidth, int edcolor, int edvis) { +/* Spits out the attributes for the edges of filled-area elements. It may + * seem logical that these would be the same as the corresponding line + * attributes, but this is not the case. + * These attributes stay in effect until changed, so you don't have to output + * them every time. + * Set the following attributes: + * Edge Type (integers 1-5, corresponding to: solid, dash, dot, + * dash-dot, dash-dot-dot. These are the same as those used + * for line type.) + * Edge Width (should be the same as line width) + * Edge Colour (index into the color table) + * Edge Visibility (integer 0 or 1, corresponding to: Off, On) + */ + if (!cdSetEdgeType(im, edtype)) return 0; + if (!cdSetEdgeWidth(im, edwidth)) return 0; + if (!cdSetEdgeColor(im, edcolor)) return 0; + if (!cdSetEdgeVis(im, edvis)) return 0; + + return 1; +} + +int cdSetTextAttrib(cdImagePtr im, int font, int color, int height) { +/* Set the attributes of text. the font is an integer pointer into the + * font list where: + * 1 Times + * 2 Times Bold + * 3 Times Italic + * 4 Times Bold Italic + * 5 Helvetica + * 6 Helvetica Bold + * 7 Helvetica Italic + * 8 Helvetica Bold Italic + * color is an index into the colortable which is the color of the text + * size is the approximate size you want the text written in. + */ + + if(!cdSetTextFont(im, font)) return 0; + if(!cdSetTextColor(im, color)) return 0; + if(!cdSetTextHeight(im, height)) return 0; + + return 1; +} + + +int cdImageDestroy(cdImagePtr im) +/* gej: should work, unless I make changes to cdImage Struct */ +{ + if (im->elemlist) { + free(im->elemlist); + } + free(im); + + return 1; +} + +int cdImageColorClosest(cdImagePtr im, int r, int g, int b) +/* From gd library, see README file for copyright information */ +/* gej: should work unchanged */ +/* gej: 5/96, changed the colors to use short int */ +{ + short int i; + long rd, gd, bd; + int ct = (-1); + long mindist = 0; + for (i=0; (i<(im->colorsTotal)); i++) { + long dist; + if (im->open[i]) { + continue; + } + rd = (im->red[i] - r); + gd = (im->green[i] - g); + bd = (im->blue[i] - b); + dist = rd * rd + gd * gd + bd * bd; + if ((i == 0) || (dist < mindist)) { + mindist = dist; + ct = i; + } + } + return ct; +} + +int cdImageColorClear(cdImagePtr im) { +/* mark all entries in the color table as open */ + short int i; + for (i=0; (i<(cdMaxColors)); i++) { + im->open[i] = 1; + } + return 1; +} + +int cdImageColorExact(cdImagePtr im, int r, int g, int b) +/* From gd library, see README file for copyright information */ +/* gej: should work unchanged */ +/* gej: 5/96, changed colors to work with short ints */ +{ + short int i; + for (i=0; (i<(im->colorsTotal)); i++) { + if (im->open[i]) { + continue; + } + if ((im->red[i] == r) && + (im->green[i] == g) && + (im->blue[i] == b)) { + return i; + } + } + return -1; +} + +static int cdImageAddColor(cdImagePtr im, int ct, int r, int g, int b) +/* adds a color to the cgm file. Does not allocate it in the + * cdImagePtr object. Use cdImageColorAllocate, not this one. + */ +{ + unsigned char *cts, *ctsp; /* GEJ: color table attribute */ + int octet_count; /* GEJ: octet count */ + /* + * Attribute: Colour Table; Elem Class 5; Elem ID 34 + * two parameters P1: Starting colour table index (1 octet, UI) + * P2: list of direct colour values 3-tuples (3 one-octet values) + */ + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + cts = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!cts) return -1; /* memory allocation failed */ + ctsp=cts; + *ctsp = *ctsp | b6 | b4; /* set elem class to 5 */ + *ctsp = *ctsp | b2; /* set elem id to 34 */ + ctsp++; + *ctsp = *ctsp | b6; + *ctsp = *ctsp | b2; /* set param list len to 4 */ + ctsp++; + octet_count = 2; /* so far */ + /* now fill in the index number */ + *ctsp = (unsigned char) 0377 & ct; /* mask off last 8 bits and put in ctsp*/ + ctsp++;octet_count++; + /* now fill in the RGB values */ + *ctsp = (unsigned char) 0377 & r; /* mask off last 8 bits and put in ctsp*/ + ctsp++;octet_count++; + *ctsp = (unsigned char) 0377 & g; /* mask off last 8 bits and put in ctsp*/ + ctsp++;octet_count++; + *ctsp = (unsigned char) 0377 & b; /* mask off last 8 bits and put in ctsp*/ + ctsp++;octet_count++; + /* add it to the buffer */ + if (cdAddElem(im, cts, octet_count)) { + free(cts); + return 1; + } + else { + free(cts); + return -1; + } + + +} + +int cdImageColorAllocate(cdImagePtr im, int r, int g, int b) +/* From gd library, see README file for copyright information + * gej: modified to allocate the color in the CGM buffer as well + * as the color table */ +/* gej: 5/96, modified to use short ints for colors */ +{ + short int i; + short int ct = (-1); + for (i=0; (i<(im->colorsTotal)); i++) { + if (im->open[i]) { + ct = i; + break; + } + } + if (ct == (-1)) { + ct = im->colorsTotal; + if (ct == cdMaxColors) { + return -1; + } + im->colorsTotal++; + } + im->red[ct] = (short int) r; + im->green[ct] = (short int) g; + im->blue[ct] = (short int) b; + im->open[ct] = (short int) 0; + /* GEJ: Now we have successfully alocated it in the color table + * so let's put it in the CGM as well. + */ + if (!cdImageAddColor(im, ct, r, g, b) ) { + return -1; + } + else { + return ct; + } + +} + +int cdImageColor16(cdImagePtr im) { +/* allocate the 16 basic colors in the windows pallete */ + if( -1 == cdImageColorAllocate(im, 255, 255, 255)) return 0; + if( -1 == cdImageColorAllocate(im, 0, 0, 0)) return 0; + if( -1 == cdImageColorAllocate(im, 128, 0, 0)) return 0; + if( -1 == cdImageColorAllocate(im, 0, 128, 0)) return 0; + if( -1 == cdImageColorAllocate(im, 128, 128, 0)) return 0; + if( -1 == cdImageColorAllocate(im, 0, 0, 128)) return 0; + if( -1 == cdImageColorAllocate(im, 128, 0, 128)) return 0; + if( -1 == cdImageColorAllocate(im, 0, 128, 128)) return 0; + if( -1 == cdImageColorAllocate(im, 128, 128, 128)) return 0; + if( -1 == cdImageColorAllocate(im, 192, 192, 192)) return 0; + if( -1 == cdImageColorAllocate(im, 255, 0, 0)) return 0; + if( -1 == cdImageColorAllocate(im, 0, 255, 0)) return 0; + if( -1 == cdImageColorAllocate(im, 255, 255, 0)) return 0; + if( -1 == cdImageColorAllocate(im, 0, 0, 255)) return 0; + if( -1 == cdImageColorAllocate(im, 255, 0, 255)) return 0; + if( -1 == cdImageColorAllocate(im, 0, 255, 255)) return 0; + + return 1; + +} + +int cdImageColorDeallocate(cdImagePtr im, int color) +/* From gd library, see README file for copyright information */ +/* gej: should work unchanged */ +{ + /* Mark it open. */ + /*im->open[color] = 1;*/ + /* gej: really can't work, we are not allowing redefinition + * of color table entries */ + return 0; +} + +int cdLine(cdImagePtr im, int x1, int y1, int x2, int y2) +/* Graphic Primitive: Polyline; Elem Class 4; Elem ID 1 + * Actually generate the line, if you are writing a program to use this + * library, use this function, not cdImageLine or cdImageDashedLine, + * those are just in for compatiblilty with gd + * + * This function will draw a line using the current line type, width, and color + */ +{ + + unsigned char *es, *esp; + int octet_count; + short int sweet; + short int sour; + + /* check to make sure the line is withing the scope of the picture + * ie. the values you give for drawing the line are within + * the values you created the picture with */ + if (!(cdImageBoundsSafe(im, x1,y1)) || !(cdImageBoundsSafe(im, x2,y2))) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if (!cdcomhead(es, 4, 1, 8)) return 0; + es += 2; + octet_count = 2; + + /* now we are ready for the parameter data */ + sweet = (short int) x1; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) y1; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) x2; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) y2; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + octet_count++; + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + + +} + +int cdRectangle(cdImagePtr im, int x1, int y1, int x2, int y2) { +/* Graphic Primitive: rectangle; Elem Class 4; Elem ID 11 + * Actually generate the rectangle, if you are writing a program to use this + * library, use this function, not cdImageRectangle, + * those are just in for compatiblilty with gd + * + * This function will draw a Rectangle using the current + * edge type, width, color, and visibility, and the current + * fill style, color, and hatch + */ + unsigned char *es, *esp; + int octet_count; + short int sweet; + short int sour; + + /* check to make sure the line is withing the scope of the picture + * ie. the values you give for drawing the line are within + * the values you created the picture with */ + if (!(cdImageBoundsSafe(im, x1,y1)) || !(cdImageBoundsSafe(im, x2,y2))) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + /* their are four 16 bit signed integers as attributes */ + if (!cdcomhead(es, 4, 11, 8)) return 0; + es +=2; octet_count = 2; + + /* now we are ready for the parameter data */ + sweet = (short int) x1; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) y1; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) x2; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) y2; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + octet_count++; + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + + +} + +int cdCircle(cdImagePtr im, int cx, int cy, int r) { +/* Graphic Primitive: circle; Elem Class 4; Elem ID 12 + * cx,cy is the center of the circle, r is the radius + * + * This function will draw a Circle using the current + * edge type, width, color, and visibility, and the current + * fill style, color, and hatch + */ + unsigned char *es, *esp; + int octet_count; + short int sweet; + short int sour; + + /* check to make sure the circle is withing the scope of the picture + * ie. the values you give for drawing the circle are within + * the values you created the picture with */ + if (!(cdImageBoundsSafe(im, cx,cy))) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + /* their are three 16 bit signed integers as attributes */ + if (!cdcomhead(es, 4, 12, 6)) return 0; + es +=2; octet_count = 2; + + /* now we are ready for the parameter data */ + sweet = (short int) cx; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) cy; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) r; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + octet_count++; + + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + + +} + +int cdArc3Pt(cdImagePtr im, int sx,int sy, int ix,int iy, int ex,int ey) { +/* Graphic Primitive: Cicular Arc 3 Point; Elem Class 4; Elem ID 13 + * + * This function will draw a Circular Arc using the current + * Line type, width, and color, + */ + unsigned char *es, *esp; + int octet_count; + short int sweet; + short int sour; + + /* check to make sure the line is withing the scope of the picture + * ie. the values you give for drawing the line are within + * the values you created the picture with */ + if (!(cdImageBoundsSafe(im, sx,sy)) || !(cdImageBoundsSafe(im, ix,iy)) || !(cdImageBoundsSafe(im, ex, ey))) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + /* their are six 16 bit signed integers as attributes */ + if (!cdcomhead(es, 4, 13, 12)) return 0; + es +=2; octet_count = 2; + + /* now we are ready for the parameter data */ + sweet = (short int) sx; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) sy; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) ix; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) iy; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) ex; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + es++; octet_count++; + sweet = (short int) ey; + sour = sweet >> 8; + *es = *es | (sour & 0377); + es++; octet_count++; + *es = (unsigned char) sweet; + octet_count++; + + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdArc3PtClose(cdImagePtr im, int sx,int sy, int ix,int iy, int ex,int ey, int cl) { +/* Graphic Primitive: Cicular Arc 3 Point Close; Elem Class 4; Elem ID 14 + * + * This function will draw a Circle using the current + * edge type, width, color, and visibility, and the current + * fill style, color, and hatch + * + * cd is the closure type. It can be either 0 for pie closure or + * 1 for chord closure. + */ + unsigned char *es, *esp; + int octet_count; + + /* check to make sure the line is withing the scope of the picture + * ie. the values you give for drawing the line are within + * the values you created the picture with */ + if (!(cdImageBoundsSafe(im, sx,sy)) || !(cdImageBoundsSafe(im, ix,iy)) || !(cdImageBoundsSafe(im, ex, ey))) + return 0; + + /* make sure that they close the arc either with pie (0) or chord (1) */ + if ((cl != 0) && (cl != 1)) + return 0; + + /* allocate sufficent space. should be 32 bits * 6 to be safe */ + es = (unsigned char *) calloc(4*6, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + /* their are seven 16 bit signed integers as attributes */ + if (!cdcomhead(es, 4, 14, 14)) return 0; + es +=2; octet_count = 2; + + /* now we are ready for the parameter data */ + octet_count += cdAppShort(es, (short int) sx); + es +=2; + octet_count += cdAppShort(es, (short int) sy); + es +=2; + octet_count += cdAppShort(es, (short int) ix); + es +=2; + octet_count += cdAppShort(es, (short int) iy); + es +=2; + octet_count += cdAppShort(es, (short int) ex); + es +=2; + octet_count += cdAppShort(es, (short int) ey); + es +=2; + octet_count += cdAppShort(es, (short int) cl); + es +=2; + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdEllipse(cdImagePtr im, int cx,int cy, int d1x,int d1y, int d2x,int d2y ) { +/* Graphic Primitive: Ellipse; Elem Class 4; Elem ID 17 + * + * This function will draw an Ellipse using the current + * edge type, width, color, and visibility, and the current + * fill style, color, and hatch + */ + unsigned char *es, *esp; + int octet_count; + + /* check to make sure the line is withing the scope of the picture + * ie. the values you give for drawing the line are within + * the values you created the picture with */ + if (!(cdImageBoundsSafe(im, cx,cy)) || !(cdImageBoundsSafe(im, d1x,d1y)) || !(cdImageBoundsSafe(im, d2x, d2y))) + return 0; + + /* allocate sufficent space. should be 32 bits * 4 to be safe */ + es = (unsigned char *) calloc(4*4, SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + /* their are six 16 bit signed integers as attributes */ + if (!cdcomhead(es, 4, 17, 12)) return 0; + es +=2; octet_count = 2; + + /* now we are ready for the parameter data */ + octet_count += cdAppShort(es, (short int) cx); + es +=2; + octet_count += cdAppShort(es, (short int) cy); + es +=2; + octet_count += cdAppShort(es, (short int) d1x); + es +=2; + octet_count += cdAppShort(es, (short int) d1y); + es +=2; + octet_count += cdAppShort(es, (short int) d2x); + es +=2; + octet_count += cdAppShort(es, (short int) d2y); + es +=2; + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + + +} + +int cdPolygon(cdImagePtr im, cdPointPtr p, int n) { +/* Graphic Primitive: Polygon; Elem Class 4; Elem ID 7 + * + * cdPointPtr is defined in cd.h, basically, it is two arrays of integers + * p[m].x and p[m].y containing the x and y values respectively. n + * is the number of points in this array (not the index of the last point, + * which is n-1). n must be at least 3 (otherwise + * you really don't have much of a polygon, it is closer to a line.) + * + * This function will draw a Polygon using the current + * edge type, width, color, and visibility, and the current + * fill style, color, and hatch + */ + unsigned char *es, *esp; + int octet_count; + int x; /* counter */ + + if (n < 3) return 0; /* it is either a point or a line */ + + if (n < 8) { + /* It fits in the short form of the command, lets us + * add it right now, shall we? */ + /* allocate sufficent space. Should be 32 bits*10 to be safe */ + es = (unsigned char *) calloc(4*10,SIZEOF(unsigned char )); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + + /* their are n*2 16 bit signed integers as attributes */ + if (!cdcomhead(es, 4, 7, (n*4))) return 0; + es +=2; octet_count = 2; + + } + else if (n < 8191) { + /* there are more than 7 points in it, that sucks */ + /* gej, so basically, for this one, I set the header + * to cdcomhead(es, 4, 7, 31) then write a function for the long + * form that takes the first 15 bits of n and tags a 0 in front + * of it and puts it in es, than I do the for loop all over again + * that doesn't seem too hard. But I will leave that for another + * day. + + * keep in mind that if CDGROWLISTSIZE is smaller than n*4 + * (at most 32769) then things could fail in a most unsavory fashion. + */ + /* allocate sufficent space. 32 bits*(n+1) to be safe */ + es = (unsigned char *) calloc(4*(n+1), SIZEOF(unsigned char )); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if (!cdcomheadlong(es, 4, 7, (n*4))) return 0; + es +=4; octet_count = 4; + } + else { + /* there are more than 8191 points in it, I am not going to implement + * that, if you want it that bad, do it yourself. */ + + printf("Writing %d points\n",n); + + + /* allocate sufficent space. 32 bits*(n+1) to be safe */ + esp = (unsigned char *) calloc(4*(n+1), SIZEOF(unsigned char )); + if (!esp) return 0; /* memory allocation failed */ + es=esp; + + if (!cdcomheadlongp(es, 4, 7)) return 0; + es +=2; octet_count = 2; + + if (!cdAddElem(im, esp, octet_count)) { + free(esp); + return 0; + } + + while(n>8191) { + es=esp; + + if (!cdcomheadlongc(es, 1,8191*4)) return 0; + es +=2; octet_count = 2; + + + for (x=0; x<8191; x++) { + /* now we are ready for the parameter data */ + es += cdAppShort(es, (short int) p->x); + es += cdAppShort(es, (short int) p->y); + octet_count += 4; + p++; + } + + /* add it to the buffer */ + if (!cdAddElem(im, esp, octet_count)) { + free(esp); + return 0; + } + + n-=8191; + printf("Done 8191 have left %d\n",n); + } + printf("doing last %d normally\n",n); + + es=esp; + + if (!cdcomheadlongc(es, 0, (n*4))) return 0; + es +=2; octet_count = 2; + + + } + + + for (x=0; xx); + es += cdAppShort(es, (short int) p->y); + octet_count += 4; + p++; + } + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } +} + +int cdPolyLine(cdImagePtr im, cdPointPtr p, int n) { +/* Graphic Primitive: Polyline; Elem Class 4; Elem ID 1 + * + * cdPointPtr is defined in cd.h, basically, it is two arrays of integers + * p[m].x and p[m].y containing the x and y values respectively. n + * is the number of points in this array (not the index of the last point, + * which is n-1). if n is 2, it is a regular line, like cdline + * + * This function will draw a Polyline using the current + * line type, width, color, and visibility, + */ + unsigned char *es, *esp; + int octet_count; + int x; /* counter */ + + if (n < 2) return 0; /* it is a point */ + + if (n < 8) { + /* It fits in the short form of the command, lets us + * add it right now, shall we? */ + /* allocate sufficent space. Should be 32 bits*10 to be safe */ + es = (unsigned char *) calloc(4*10,SIZEOF(unsigned char )); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + + /* their are n*2 16 bit signed integers as attributes */ + if (!cdcomhead(es, 4, 1, (n*4))) return 0; + es +=2; octet_count = 2; + + } + else if (n < 8191) { + /* there are more than 7 points in it, that sucks */ + /* gej, so basically, for this one, I set the header + * using the long version cdcomheadlong(es, 4, 1, n*4) + + * keep in mind that if CDGROWLISTSIZE is smaller than n*4 + * (at most 32769) then the list may have to grow several times + */ + /* allocate sufficent space. 32 bits*(n+1) to be safe */ + es = (unsigned char *) calloc(4*(n+1), SIZEOF(unsigned char )); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if (!cdcomheadlong(es, 4, 1, (n*4))) return 0; + es +=4; octet_count = 4; + } + else { + /* there are more than 8191 points in it, I am not going to implement + * that, if you want it that bad, do it yourself. */ + return 0; + } + + + for (x=0; xx); + es += cdAppShort(es, (short int) p->y); + octet_count += 4; + p++; + } + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } +} + +int cdText(cdImagePtr im, int x, int y, const char *ts) { +/* Graphic Primitive: Text; Elem Class 4; Elem ID 4 + * add text to the picture. Start it at the point (x,y) + * this should be the lower left corner of where the text is + * the parameters are point, enumerated(set to 1), string + * + * String encoding in CGM is a little strange. After you have the other + * parameter info, the first octet for the string is either 0..254 which + * is the number of octets of string data, or 255 which signifies a long + * string. if it is 255 then the next 16 bits indicate the length of the + * string. the first bit (bit15) is 0 if this is the last part of the + * string and 1 if another part follows it. the next 15 bits are in the + * range 0..32767 and are the number of octets of string info following. + * so the length stored in the command header is the whole enchelada. + */ + int tslen, curly; + unsigned char *es, *esp; + int octet_count; + + /* check to make sure the Text is within the scope of the picture + * actually, I am only checking the start of it + */ + if (!(cdImageBoundsSafe(im, x, y))) + return 0; + + /* allocate sufficent space. should be tslen+ 32 bits * 4 to be safe */ + tslen = strlen(ts); + + /* if there are more than 32700 characters fail + * gej: this could go as high as 32767 I think, but lets + * cut it off at 32700 */ + if ((tslen > 32700) || (tslen < 0))return 0; + + es = (unsigned char *) calloc( ((4*4)+tslen), SIZEOF(unsigned char ) ); + if (!es) return 0; /* memory allocation failed */ + esp=es; + + if (!cdcomheadlong(es, 4, 4, 9+tslen)) return 0; + es +=4; octet_count = 4; + + /* add the x position, the y position, then 1, which signifies + * that this is all the text, there is none appended after it */ + es += cdAppShort(es, (short int) x); + es += cdAppShort(es, (short int) y); + es += cdAppShort(es, (short int) 1); + octet_count += 6; + + /* now take care of the string information, for strings 254 bytes + * or less, I could use a short one, but why bother, use the long + * form for everything */ + es += cdAppByte(es, (short int) 255); + es += cdAppShort(es, (short int) tslen); + octet_count += 3; + /* gej: I should set bit 15 to 0 because it is the final part of a + * string but I am not going to since I already checked that it was + * a 16 number that was non-negative */ + + while(*ts) { + *es++ = (unsigned char) *ts++; + } + octet_count +=tslen; + /* now if the octet_count is not divisible by 4 add null padding */ + curly = 4 - (octet_count % 4); + if (curly % 4) { + octet_count += curly; + es += cdAppNull(es, curly); + } + + /* add it to the buffer */ + if (cdAddElem(im, esp, octet_count)) { + free(esp); + return 1; + } + else { + free(esp); + return 0; + } + +} + +int cdImageLine(cdImagePtr im, int x1, int y1, int x2, int y2, int color) +/* gej: this should be so much easier to do as a cgm + * This is in for compatibility with gd, if you don't need that, use + * cdLine instead */ +{ + int ltstate; + + + /* save the linetype state */ + ltstate = im->ltype; + /* set the attributes of the line */ + if (!cdSetLineAttrib(im, 1, -1, color)) return 0; + if (!cdLine(im, x1, y1, x2, y2)) return 0;/* draw the line */ + /* restore the state If it fails, don't return an error, because + * the line was still drawn */ + cdSetLineType(im, ltstate); + + return 1; +} + +int cdImageDashedLine(cdImagePtr im, int x1, int y1, int x2, int y2, int color) +/* gej: this should be so much easier to do as a cgm + * in order to really get a dashed line you must call cdSetLineType first + * This is in for compatibility with gd, if you don't need that, use + * cdLine instead */ +{ + /* set the attributes of the line */ + if (!cdSetLineAttrib(im, -1, -1, color)) return 0; + /* generate the line */ + if (!cdLine(im, x1, y1, x2, y2)) return 0; + + /* everthing is A-OK */ + return 1; +} + +int cdImageBoundsSafe(cdImagePtr im, int x, int y) +/* From gd library, see README file for copyright information */ +/* gej: this should work unchanged */ +{ + return (!(((y < 0) || (y >= im->sy)) || + ((x < 0) || (x >= im->sx)))); +} + + +int cdImageRectangle(cdImagePtr im, int x1, int y1, int x2, int y2, int color) +/* Graphic Primitive: rectangle; Elem Class 4; Elem ID 11 + */ + +/* gej: but I think I will use the cgm rectangle */ +{ + if(!cdImageLine(im, x1, y1, x2, y1, color)) return 0; + if(!cdImageLine(im, x1, y2, x2, y2, color)) return 0; + if(!cdImageLine(im, x1, y1, x1, y2, color)) return 0; + if(!cdImageLine(im, x2, y1, x2, y2, color)) return 0; + + return 1; +} diff --git a/src/cd/cd.h b/src/cd/cd.h new file mode 100644 index 0000000..3bb303e --- /dev/null +++ b/src/cd/cd.h @@ -0,0 +1,209 @@ +#ifndef CD_H +#define CD_H 1 + +/* cd.h: declarations file for the cgmdraw module. + + Written by G. Edward Johnson + Date: April 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + + Portions of this package are from the gd package written by + Thomas Boutell and are copyright 1994, 1995, Quest Protein + Database Center, Cold Spring Harbor Labs. They are marked in the + source code. + +*/ + +/* #include */ + +/* stdio is needed for file I/O. */ +#include + +/* This can not be changed to a value larger than 256, though smaller + * values can be used. + */ + +#define cdMaxColors 256 + +/* If you know you will be working with large pictures, increase the values + * of the next two constants. + */ + +/* The initial size of the element list. When it fills up, we will just + * make it bigger. Starting with a larger number reduces the frequency of + * the list growing, but increases the memory needed for small pictures + */ + +#define CDSTARTLISTSIZE 4096 + +/* How much the element list grows by. When the list fills up, we allocate + * a new larger list. This number is how much larger. using a larger number + * decreases the frequency of the list growing, but if only a small amount + * more is needed, it could waste memory + */ + +#define CDGROWLISTSIZE 2048 + +/* Image type. See functions below; you will not need to change + the elements directly. Use the provided macros to + access sx, sy, the color table, and colorsTotal for + read-only purposes. */ + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +typedef struct cdImageStruct { + unsigned char * elemlist; + int sx; + int sy; + int colorsTotal; + int red[cdMaxColors]; + int green[cdMaxColors]; + int blue[cdMaxColors]; + int open[cdMaxColors]; + /* You can have multiple pictures in the file, this keeps track + * of which one you are on */ + int picnum; + /* Linetype, line width, line color have a broader scope in CGM */ + int ltype; + int lwidth; + int lcolor; + /* interior style [of filled objects] (for me) can be empty, hollow, + * solid, hatch [don't do pattern, geometric pattern, interpolated*/ + int shapestyle; + /* fill color, color used on inside of closed objects, significant + * if interior style is hollow, solid, hatch, or geometric pattern */ + int shapecolor; + /* hatch index, which hatch style to use, 1=horizontal, 2=vertical, + * 3=pos.slope, 4=neg.slope, 5=hor/vert.crosshatch, + * 6=pos/neg.crosshatch*/ + int shapehatch; + /* The edges of filled shapes can have line styles too. They + * correspond to the ones for lines. These next few set them. */ + int edgetype; + int edgewidth; + int edgecolor; + int edgevis; /* is the edge visible or invisible */ + /* now for the TEXT related attributes, Text Color, Text Height, + * and Text font index */ + int textcolor; + int textheight; + int textfont; + int textpath; + /* the next three are used for maintaining the element list */ + long int bytestoend; /* number of bytes to end of the element list */ + long int listlen; /* the total length of the element list */ + unsigned char * curelemlist; /* where we curently are in the list */ +} cdImage; + +typedef cdImage * cdImagePtr; + + +/* Point type for use in polygon drawing. */ + +typedef struct cdPointStruct{ + int x, y; +} cdPoint, *cdPointPtr; + + + +/* Functions to manipulate images. */ + +cdImagePtr cdImageCreate(int sx, int sy); +int cdCgmNewPic(cdImagePtr im, int sticky); +int cdImageCgm(cdImagePtr im, FILE *); +int cdImageDestroy(cdImagePtr im); + +/* Use cdLine, not cdImageLine */ +int cdLine(cdImagePtr im, int x1, int y1, int x2, int y2); +/* Corners specified (not width and height). Upper left first, lower right + second. */ +int cdRectangle(cdImagePtr im, int x1, int y1, int x2, int y2); +/* center x, then center y, then radius of circle */ +int cdCircle(cdImagePtr im, int cx, int cy, int r); +/* start, middle and end of arc */ +int cdArc3Pt(cdImagePtr im, int sx,int sy, int ix,int iy, int ex,int ey); +/* cl is 0 for pie closure, 1 for cord closure */ +int cdArc3PtClose(cdImagePtr im, int sx,int sy, int ix,int iy, int ex,int ey, int cl); +int cdEllipse(cdImagePtr im, int cx,int cy, int d1x,int d1y, int d2x,int d2y ); +/* polyshapes */ +int cdPolygon(cdImagePtr im, cdPointPtr p, int n); +int cdPolyLine(cdImagePtr im, cdPointPtr p, int n); + +/* Functions for Compatibility with gd */ +int cdImageLine(cdImagePtr im, int x1, int y1, int x2, int y2, int color); +int cdImageRectangle(cdImagePtr im, int x1, int y1, int x2, int y2, int color); + + +int cdImageBoundsSafe(cdImagePtr im, int x, int y); +/* These put characters in the picture. CGM can handle fonts*/ +/* (x,y) is the lower left corner of where the text goes */ +int cdText(cdImagePtr im, int x, int y, const char *); + + +/* Functions for allocating colors */ +int cdImageColorAllocate(cdImagePtr im, int r, int g, int b); +int cdImageColorClosest(cdImagePtr im, int r, int g, int b); +int cdImageColorExact(cdImagePtr im, int r, int g, int b); +int cdImageColorDeallocate(cdImagePtr im, int color); +int cdImageColor16(cdImagePtr im); + +/* gej: functions that set style attributes */ +int cdSetLineAttrib(cdImagePtr im, int lntype, int lnwidth, int lncolor); +int cdSetShapeFillAttrib(cdImagePtr im, int instyle, int incolor, int inhatch); +int cdSetShapeEdgeAttrib(cdImagePtr im, int edtype, int edwidth, int edcolor, int edvis); +int cdSetTextAttrib(cdImagePtr im, int font, int color, int height); +/* gej: or if you prefer, set the attributes individually */ +int cdSetLineType(cdImagePtr im, int lntype); +int cdSetLineWidth(cdImagePtr im, int lnwidth); +int cdSetLineColor(cdImagePtr im, int lncolor); +int cdSetFillStyle(cdImagePtr im, int instyle); +int cdSetFillColor(cdImagePtr im, int incolor); +int cdSetFillHatch(cdImagePtr im, int inhatch); +int cdSetEdgeType(cdImagePtr im, int edtype); +int cdSetEdgeWidth(cdImagePtr im, int edwidth); +int cdSetEdgeColor(cdImagePtr im, int edcolor); +int cdSetEdgeVis(cdImagePtr im, int edvis); +int cdSetTextFont(cdImagePtr im, int font); +int cdSetTextColor(cdImagePtr im, int color); +int cdSetTextHeight(cdImagePtr im, int height); +/* geJ: these individual attributes can't be set with a group function */ +int cdSetTextPath(cdImagePtr im, int tpath); +int cdSetTextOrient(cdImagePtr im, int xup, int yup, int xbase, int ybase); + +/* Macros to access information about images. READ ONLY. Changing + these values will NOT have the desired result. */ +#define cdImageSX(im) ((im)->sx) +#define cdImageSY(im) ((im)->sy) +#define cdImageColorsTotal(im) ((im)->colorsTotal) +#define cdImageRed(im, c) ((im)->red[(c)]) +#define cdImageGreen(im, c) ((im)->green[(c)]) +#define cdImageBlue(im, c) ((im)->blue[(c)]) + +/* Source: Independent JPEG Group + * In ANSI C, and indeed any rational implementation, size_t is also the + * type returned by sizeof(). However, it seems there are some irrational + * implementations out there, in which sizeof() returns an int even though + * size_t is defined as long or unsigned long. To ensure consistent results + * we always use this SIZEOF() macro in place of using sizeof() directly. + */ + +#define SIZEOF(object) ((size_t) sizeof(object)) + +/* GeJ: these are helper functions I use in cd. That means DON'T call + * them from your program. Yes, that means you. */ +int cdCgmHeader(cdImagePtr); +int cdCgmPic(cdImagePtr, int); +int cdImageColorClear(cdImagePtr im); + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + + +#endif diff --git a/src/cd/cd.html b/src/cd/cd.html new file mode 100644 index 0000000..31471b1 --- /dev/null +++ b/src/cd/cd.html @@ -0,0 +1,1156 @@ + + + + + +CD -- CGM Draw Documentation + + +

CD Documentation

+

A graphics library for fast CGM creation

+

Follow this link for the +latest version +of the CD documentation.

+ +

Table of Contents

+ + +

Credits and license terms

 + +

cd was written by G. +Edward Johnson at the National +Institute of Standards and Technology. You may use this code +for any purpose, but please give us credit. If find cd useful, please +let us know. +cd software produced by NIST, an agency of the U.S. government, +is by statute not subject to copyright in the United States. +Recipients of this software assume all responsibilities associated +with its operation, modification and maintenance. +

+Some of this code is from the gd library written by Thomas Boutell. +Mr. Boutell did not help with this project, so do not send him questions +about cd. +Code from gd is clearly marked in the source. Additionally, this document +is patterned after the gd documentation, some portions have been copied +verbatim. gd is covered by the following license.

+

+gd 1.2 is copyright 1994, 1995, Quest Protein Database Center, +Cold Spring Harbor Labs. Permission granted to copy and distribute +this work provided that this notice remains intact. Credit +for the library must be given to the Quest Protein Database Center, +Cold Spring Harbor Labs, in all derived works. This does not +affect your ownership of the derived work itself, and the intent +is to assure proper credit for Quest, not to interfere with your +use of gd. If you have questions, ask. ("Derived works" +includes all programs that utilize the library. Credit must +be given in user-visible documentation.)

+

+The Quest Protein Database Center is funded under Grant P41-RR02188 by +the National Institutes of Health. +

+

What's new?

 +

Version 1.2

+

+

    +
  • New Text attributes: +
      +
    • cdSetTextPath sets the text direction as right, left, up, or down
      • +
    • cdSetTextOrient sets the angle of the text
      • +
    • +
  • Multiple pictures in a file. Now you can put more than one + picture in a cgm file, see cdCgmNewPic for details.
    • +
  • Internal changes like using short int's in some places so it may + take less space in memory when using 16 or 64 bit compilers.
    • +
  • New example programs. +
      +
    • cdtext to show the new text attributes.
      • +
    • cdmulti to show the multiple picture capability.
      • +
    • +
+ +

Version 1.1

+

Thanks to Wolfgang Glunz who purified it, +pointed out some bugs and did the Borland makefile. +

    +
  • Switched from using malloc to calloc most cases, solving an off + by one error in a function I then eliminated.
    • +
  • Added a Makefile for Borland Turbo C++
    • +
  • Fixed a couple of spelling errors, cleared out some dead code, and + some other trivial things.
    • +
  • Added a new example program cdsimple which walks you through some + basics.
    • +
  • Added a new function cdPolyLine for when you want lines + with more than two points
    • +
+

+ +

Version 1.0

+

Basically, everything is new, this is the first release. +

+

What is cd?

 +

+cd is a graphics library. It allows your code to quickly draw +images complete with lines, arcs, rectangles, polygons, text, and multiple +colors. most geometric shapes can be filled or have a hatch pattern as well. +The output is a CGM file. If you are unsure of what CGM is, or if +CGM is appropriate for your project, see the +NIST CGM Homepage. +

+Every effort has been made to ensure that the generated cgm files +conform to the standard, however, if you do not use the library +properly, you could generate invalid metafiles that no one is able +to read, so be careful. +

+ + +

What else do I need to use cd?

 +

+To use cd, you will need an ANSI C compiler. Any full-ANSI-standard +C compiler should be adequate, although those with PCs will need to replace +the Makefile with one of their own. The cc compiler released +with SunOS 4.1.3 is not an ANSI C compiler. Get gcc, which is freely +available. See the Sun-related newsgroups for more information. +

+You will also want a CGM viewer, if you do not already have +one for your system, since you will need a good way to check the +results of your work. +

+

How do I get cd?

 +

+ +You can + +fetch cd as a gzip'ed tar file, or you can FTP it directly from +zing.ncsl.nist.gov in the subdirectory cgm. +

+

How do I build cd?

 +

+Note: if you have a non-Unix system, you will need +to acquire versions of "gunzip" and "tar" suitable for +your system. Both have been ported to PC and Mac +environments. Consult newsgroups relevant to your +particular system. +

+gunzip cd1.2.tar.gz
+tar -xf cd1.2.tar
+
+This will create the directory "cd1.2" beneath the current +directory. +

+change to this directory and examine the Makefile, which you may need +to change slightly depending on your installation (or more than +slightly for a Windows or Mac environment). +On UNIX systems the command "make all" will create the cd library +and three example programs, cdsimple, cdtest, +and color16. If you are using Borland Turbo C++ version 3 +(or later I hope) try to make it using makefile.bor +

+CGM files are always in Network Byte order, Big-Endian systems use this +ordering. I wrote this on a Big-Endian machine, but it seems to work on +Little-Endian's as well. I have Tested cd on Sun's, Ultrix, Linux, +IRIX, and DOS (Borland). +If you get it to run on other systems, drop me a note. +

+ +

cd basics: using cd in your program

 +

+cd lets you create CGM images on the fly. To use cd in your +program, include the file cd.h, and link with the libcd.a +library produced by "make libcd.a", under Unix. You will +need to adapt the makefile for your needs if you are using +a non-Unix operating system, but this is very straightforward. +

+Look at the example programs included in this distribution for +examples of using cd. The programs are cdsimple which is +a heavily commented program that makes a small cgm. cdtest which +makes a cgm with every different kind of shape you can use. It +has lines, circles, arcs, ellipses, rectangles, polygons, and text as +well as examples for setting the attributes for them. So look +at it closely, it is your friend. The other example program, +color16 allocates 16 colors using cdImageColor16 (these +are the 16 standard Windows colors). Than it draws a rectangle +with each of them. These programs are created automatically when you +"make all". +

+ + +

Function and Type reference

+ + +

Types

+ +
+
+cdImage +(Type)
+
The data structure in which cd stores images. + cdImageCreate returns a pointer to this + type, and other functions expect to receive a pointer to this type as + their first argument. +
+ +
+cdImagePtr +(Type)
+
A pointer to an image structure. + cdImageCreate returns this type, and the other + functions expect it as the first argument. you may read the members + sx (size of x axis), sy (size of y axis), + colorsTotal (total colors allocated), red (red component + of colors; an array of 256 integers between 0 and 255), + green (green commponent of colors), and blue (blue + component of colors). Please do so using the macros provided. + Do Not set the members directly from your code, use + the functions provided. +
+ +
+cdPoint +(Type)
+
Represents a collection of points in the coordinate space of the image; + used by cdPolygon and + by cdPolyLine. +

+ cdPointPtr is defined in cd.h, basically, it is an array of integer pairs + p[m].x and p[m].y containing the x and y values respectively. pcnt + is the number of points in this array (not the index of the last point, + which is pcnt-1). pcnt must be at least 3 for polygons or 2 for + polylines. +

+ Declare it with cdPoint points[pcnt] where pcnt + is the upper limit of the number of points you wish to have. then fill + it in with points[0].x = x0; points[0].y = y0; and the like. +

+ +
+cdPointPtr +(Type) +
A pointer to a cdPoint structure; passed + as an argument to cdPolygon + and to cdPolyLine. +
+ +
+ + +

Image creation, destruction, and saving

+ + +
+
+cdImageCreate(int sx, int sy) +(Function)
+
cdImageCreate is called to create images. Invoke cdImageCreate with + the x and y dimensions of the desired image. cdImageCreate returns a + cdImagePtr to the new image, or NULL if unable + to allocate the image. The image must eventually be destroyed + using cdImageDestroy +
+ +
+cdImageDestroy(cdImagePtr im) +(Function)
+
cdImageDestroy is used to free the memory associated with + and image. It is important to invoke cdImageDestroy before exiting + your program or assigning a new image to a + cdImagePtr variable. +
+ +
+cdCgmNewPic(cdImagePtr im, int sticky) +(Function)
+
cdCgmNewPic allows for a single CGM file to contain multiple + pictures. If sticky is 0 then all attributes will be reset to + their default condition and the color table will be cleared. + If sticky is 1 then all attributes and the color table will + be carried over to the new picture. + NOTE: as of now (version 1.2) the only allowable value + for sticky is 0. If you set it to 1, the function will fail. +
+ +
+cdImageCgm(cdImagePtr im, FILE *out) +(Function)
+
cdImageCgm outputs the specified image to the specified file + in the CGM image format. The file must be open for + writing. Under MSDOS, it is important to use "wb" as opposed to simply + "w" as the mode when opening the file, and under UNIX there is no penalty + for doing so. cdImageCgm does not close the file, your code + must do that. +
+ +
+ + +

Drawing Functions

+ + +
+
+int cdLine(cdImagePtr im, int x1, int y1, int x2, int y2) +(Function)
+
Graphic Primitive: Polyline; Elem Class 4; Elem ID 1
+ Returns 1 for success, 0 for failure. + cdLine is used to draw a line between two endpoints (x1,y1) and (x2,y2) + This line is drawn using the attributes set by + cdSetLineAttrib + The attributes that may be set are Line Type, + Line Width, or + Line Color. + The endpoints must be within the bounds of the picture. +
+ +
+int cdPolyLine(cdImagePtr im, cdPointPtr p, int n) +(Function)
+
Graphic Primitive: Polyline; Elem Class 4; Elem ID 1
+ Returns 1 for success, 0 for failure. + cdPolyLine draws a line connecting all the points specified by + cdPointPtr. n is the number of + points in cdPointPtr, (not the index of the last point, which is n-1). + This line is drawn using the attributes set by + cdSetLineAttrib + The attributes that may be set are Line Type, + Line Width, or + Line Color. + Note that it uses line attributes not edge attributes for drawing the + line. + The endpoints must be within the bounds of the picture. +

+ cdPointPtr is defined in cd.h, basically, it is two arrays of integers + p[m].x and p[m].y containing the x and y values respectively. n + is the number of points in this array (not the index of the last point, + which is n-1). n must be at least 2 (otherwise + you really don't have much of a line, it is closer to a point.) +

+ +
+int cdRectangle(cdImagePtr im, int x1, int y1, int x2, int y2) +(Function)
+
Graphic Primitive: rectangle; Elem Class 4; Elem ID 11
+ Returns 1 for success, 0 for failure. + cdRectangle draws a line which has (x1,y1) as the upper left corner + and (x2,y2) as the lower right corner. + This rectangle is drawn using the + attributes set by cdSetShapeFillAttrib + and by cdSetShapeEdgeAttrib. + The fill attributes that may be set are + Fill Style, + Fill Color, or + Fill Hatch. + The edge attributes that may be set are + Edge Type, + Edge Width, + Edge Color, or + Edge Visibility. + Note that it uses Edge attributes not line attributes for drawing the + perimeter of the rectangle. + The Rectangle must be within the bounds of the picture. +
+ + +
+int cdCircle(cdImagePtr im, int cx, int cy, int r) +(Function)
+
Graphic Primitive: circle; Elem Class 4; Elem ID 12
+ Returns 1 for success, 0 for failure. + cdCircle draws a circle which has center (cx, cy) and radius r. + This circle is drawn using the attributes set by + cdSetShapeFillAttrib + and by cdSetShapeEdgeAttrib. + The fill attributes that may be set are + Fill Style, + Fill Color, or + Fill Hatch. + The edge attributes that may be set are + Edge Type, + Edge Width, + Edge Color, or + Edge Visibility. + Note that it uses Edge attributes not line attributes for drawing the + perimeter of the Circle. + The Circle must be within the bounds of the picture. +
+ +
+int cdArc3Pt(cdImagePtr im, int sx, int sy, int ix, int iy, int ex, int ey) +(Function)
+
Graphic Primitive: Cicular Arc 3 Point; Elem Class 4; Elem ID 13
+ Returns 1 for success, 0 for failure. + cdArc3Pt draws an arc specified by the given points. (sx,sy) is the + start of the arc, (ix,iy) is the middle of the arc, and (ex,ey) is the + end of the arc. + This arc is drawn using the attributes set by + cdSetLineAttrib + The attributes that may be set are Line Type, + Line Width, or + Line Color. + Note that it uses Line attributesfor drawing + the perimiter of the arc, not Edge attributes like + cdArc3PtClose. + The Arc must be within the bounds of the picture. +
+ +
+int cdArc3PtClose(cdImagePtr im, int sx, int sy, int ix, int iy, int ex, int ey, int cl) +(Function)
+
Graphic Primitive: Cicular Arc 3 Point Close; Elem Class 4; Elem ID 14
+ Returns 1 for success, 0 for failure. + cdArc3PtClose draws an arc specified by the given points. (sx,sy) is the + start of the arc, (ix,iy) is the middle of the arc, and (ex,ey) is the + end of the arc. The arc is closed base on cl. If cl is + 0 then pie closure will be used, resulting in a pie shaped slice. if + cl is 1 then cord closure will be used and a straight line will + be drawn from one endpoint to the other. + This arc is drawn using the attributes set by + cdSetShapeFillAttrib + and by cdSetShapeEdgeAttrib. + The fill attributes that may be set are + Fill Style, + Fill Color, or + Fill Hatch. + The edge attributes that may be set are + Edge Type, + Edge Width, + Edge Color, or + Edge Visibility. + Note that it uses Edge attributes for drawing the + perimeter of the arc, not Line attributes like + cdArc3Pt. + The Arc must be within the bounds of the picture. +
+ +
+int cdEllipse(cdImagePtr im, int cx, int cy, int d1x, int d1y, int d2x, int d2y) +(Function)
+
Graphic Primitive: Ellipse; Elem Class 4; Elem ID 17
+ Returns 1 for success, 0 for failure. + cdEllipse draws an ellipse specified by the given points. (cx,cy) is + the center, (d1x,d1y) is the endpoint of the first conjugate diameter, + (d2x, d2y) is the endpoint of the second conjugate diameter. I can't + really explain this one, if you come up with a good description, + mail me. + This ellipse is drawn using the attributes set by + cdSetShapeFillAttrib + and by cdSetShapeEdgeAttrib. + The fill attributes that may be set are + Fill Style, + Fill Color, or + Fill Hatch. + The edge attributes that may be set are + Edge Type, + Edge Width, + Edge Color, or + Edge Visibility. + Note that it uses Edge attributes not line attributes for drawing the + perimeter of the Ellipse. + The Ellipse must be within the bounds of the picture. +
+ +
+int cdPolygon(cdImagePtr im, cdPointPtr p, int n) +(Function)
+
Graphic Primitive: Polygon; Elem Class 4; Elem ID 7
+ Returns 1 for success, 0 for failure. + cdPolygon draws a closed polygon connecting the points specified by + cdPointPtr. n is the number of + points in cdPointPtr, (not the index of the last point, which is n-1). + This polygon is drawn using the attributes set by + cdSetShapeFillAttrib + and by cdSetShapeEdgeAttrib. + The fill attributes that may be set are + Fill Style, + Fill Color, or + Fill Hatch. + The edge attributes that may be set are + Edge Type, + Edge Width, + Edge Color, or + Edge Visibility. + Note that it uses Edge attributes not line attributes for drawing the + perimeter of the polygon. + The polygon must be within the bounds of the picture. +

+ cdPointPtr is defined in cd.h, basically, it is two arrays of integers + p[m].x and p[m].y containing the x and y values respectively. n + is the number of points in this array (not the index of the last point, + which is n-1). n must be at least 3 (otherwise + you really don't have much of a polygon, it is closer to a line.) +

+ +
+ + +

Font and text-handling functions

+ +
+
+int cdSetTextAttrib(cdImagePtr im, int font, int color, int height) +(Function)
+
+ Returns 1 for success, 0 for failure. + cdSetTextAttrib sets the attributes for text elements. + The Font functions are affected by this. + These attributes stay in effect until they are changed, you don't + have to call this function every time. If you call the function with + a value of -1 for any of the attributes they will not be changed. If + you call the function with the same value for an attribute as it + already has, it will not be changed (so you don't have to worry about + bloating your CGM with redundant attribute changes.) + It calls three functions. cdSetTextFont + to set the index into the font table, + cdSetTextColor with color to set + the forground color of the text, and + cdSetTextHeight with height to + set the height of the text. + You may also call any of the three functions individually if you like. +
+ +
+int cdText(cdImagePtr im, int x, int y, const char *ts) +(Function)
+
Graphic Primitive: Text; Elem Class 4; Elem ID 4
+ Returns 1 for success, 0 for failure. + cdText puts a string of text ts starting at position (x,y) + The Text is drawn using the attributes set with + cdSetTextAttrib. The attributes that + may be set are: + cdSetTextFont, + cdSetTextColor, or + cdSetTextHeight. + The point where the text starts must be within the bounds of the picture. +
+ +
+int cdSetTextPath(cdImagePtr im, int tpath) +(Function)
+
Attribute: Text Path; Elem Class 5; Elem ID 17
+ Returns 1 for success, 0 for failure. + sets the path of the text to tpath. tpath is an integer + with one of the following values +
    +
  • 0 for right
    • +
  • 1 for left
    • +
  • 2 for up
    • +
  • 3 for down
    • +
+ These are all relative to the charater base vector and up vector. If you + haven't changed them (with cdSetTextOrient + then the direction of the text will be right to left for 0, left to right + for 1, bottom to top for 2, and top to bottom for 3. Each individual + letter will still be facing in the normal direction. If you want to + rotate the text use cdSetTextOrient. +

+ Things get more interesting if you use + cdSetTextOrient with this function. + A more exact definition of tpath is +

    +
  • 0 right -- the direction of the character base vector
    • +
  • 1 left -- 180 degrees from the direction of the character + base vector
    • +
  • 2 up -- the direction of the character up vector
    • +
  • 3 down -- 180 degrees from the direction of the character + up vector
    • +
+

+
+ +
+int cdSetTextOrient(cdImagePtr im, int xup, int yup, int xbase, int ybase) +(Function)
+
Attribute: Character Orientation; Elem Class 5; Elem ID 16
+ Returns 1 for success, 0 for failure. + (xbase,ybase) is the run and the rise of the line that the text is + written along. For regular text that is rotated, set xup = -ybase + and yup = xbase. Setting it to something different will result in + skewed text (which may be what you want.) Text written from bottom to + top at a 90 degree angle would have the following parameters + xup=-1, yup=0, xbase=0, ybase=1 +

+ This function adds the Orientation to the metafile every time. + It does not interpert an attribute value of -1 as no change like many + functions do, although if you + put in the same numbers it won't re-add it to the meta file. +

+ +
+int cdSetTextFont(cdImagePtr im, int font) +(Function)
+
Attribute: Text Font Index; Elem Class 5; Elem ID 10
+ Returns 1 for success, 0 for failure. + Sets the font index to font. It is an index into the + font table, the possible values are: +
    +
  • 1 for Times
    • +
  • 2 for Times Bold
    • +
  • 3 for Times Italic
    • +
  • 4 for Times Bold Italic
    • +
  • 5 for Helvetica
    • +
  • 6 for Helvetica Bold
    • +
  • 7 for Helvetica Italic
    • +
  • 8 for Helvetica Bold Italic
    • +
+ font must be one of these values or the function will fail. + See cdSetTextAttrib for more information + on this and related functions. +
+ +
+int cdSetTextColor(cdImagePtr im, int color) +(Function)
+
Attribute: Text Colour; Elem Class 5; Elem ID 14
+ Returns 1 for success, 0 for failure. + Sets the foreground color of text to color. This should be + an integer which is an index into the color table that you have + previously allocated. See cdSetTextAttrib + for more information on this and related functions. +
+ +
+int cdSetTextHeight(cdImagePtr im, int height) +(Function)
+
Attribute: Character Height; Elem Class 5; Elem ID 15
+ Returns 1 for success, 0 for failure. + height is an integer for the height of the text you are displaying. + Bigger numbers make larger text. The size of the text is dependent on + the size of the picture. + See cdSetTextAttrib + for more information on this and related functions. +
+ +
+ + +

Line, Edge, and Fill attributes

+ +
+
+int cdSetLineAttrib(cdImagePtr im, int lntype, int lnwidth, int lncolor) +(Function)
+
+ Returns 1 for success, 0 for failure. + cdSetLineAttrib sets the attributes for lines and non-closed area elements. + The drawing functions affected are + + These attributes stay in effect until they are changed, you + don't have to call this function every time. If you call the function with + a value of -1 for any of the attributes they will not be changed. If + you call the function with the same value for an attribute as it + already has, it will not be changed (so you don't have to worry about + bloating your CGM with redundant attribute changes.) + It calls three functions. cdSetLineType + with lntype to set the line type (solid, dashed, etc), + cdSetLineWidth with lnwidth to + set how wide the line is, and cdSetLineColor + to set the color of the line. + You may also call any of the three functions individually if you like. +
+ +
+int cdSetShapeFillAttrib(cdImagePtr im, int instyle, int incolor, int inhatch) +(Function)
+
+ Returns 1 for success, 0 for failure. + cdSetShapeFillAttrib sets the attributes for the interior of closed area + elements. + The drawing functionsaffected are + + These attributes stay in effect until they are changed, you + don't have to call this function every time. If you call the function with + a value of -1 for any of the attributes they will not be changed. If + you call the function with the same value for an attribute as it + already has, it will not be changed (so you don't have to worry about + bloating your CGM with repetitive attribute changes. + It calls three functions. + cdSetFillStyle with instyle to set + the interior style (solid, hatch, empty), + cdSetFillColor with incolor to set + the interior color (used if instyle is solid or hatch), and + cdSetFillHatch with inhatch to set + the hatch style (hor lines, vert lines, crosshatch, etc) (used if + instyle is hatch). + You may also call any of the three functions individually if you like. +
+ +
+int cdSetShapeEdgeAttrib(cdImagePtr im, int edtype, int edwidth, int edcolor, int edvis) +(Function)
+
+ Returns 1 for success, 0 for failure. + cdSetShapeEdgeAttrib sets the attributes for the perimeter of + Filled area elements. It might seem logical to use the line attributes + instead, but that is not the case. + The drawing functionsaffected are + + These attributes stay in effect until they are changed, you + don't have to call this function every time. If you call the function with + a value of -1 for any of the attributes they will not be changed. If + you call the function with the same value for an attribute as it + already has, it will not be changed (so you don't have to worry about + bloating your CGM with redundant attribute changes.) + cdSetShapeEdgeAttrib calls three functions. + cdSetEdgeType with edtype to set + the edge type (solid, dashed, etc), + cdSetEdgeWidth with edwidth to set + the width of the line around the perimeter, + cdSetEdgeColor with edcolor to set + the color of the line around the perimeter, and + cdSetEdgeVis with edvis to determine + if the line around the perimeter is visible. + You may also call any of the three functions individually if you like. +
+ +
+int cdSetLineType(cdImagePtr im, int lntype) +(Function)
+
Attribute: Line Type; Elem Class 5; Elem ID 2
+ Returns 1 for success, 0 for failure. + lntype is the line type which is an integer with possible values + of: +
    +
  • 1 for a solid line
    • +
  • 2 for a dashed line
    • +
  • 3 for a dotted line
    • +
  • 4 for a dash-dot line
    • +
  • 5 for a dash-dot-dot line
    • +
+ lntype must be one of these values or the function will fail. + See cdSetLineAttrib for more information + on this and related functions. +
+ +
+int cdSetLineWidth(cdImagePtr im, int lnwidth) +(Function)
+
Attribute: Line Width; Elem Class 5; Elem ID 3
+ Returns 1 for success, 0 for failure. + lnwidth is an integer giving the width of lines. With an + image of height Y with line width 1 the displayed width will be 1/Y%. + As an example, if you image is x=5, y=10, and you set line width = 1, + and draw a vertical line, the resulting line will cover 20% of + horizontal area. (I think anyway). + See cdSetLineAttrib for more information + on this and related functions. +
+ +
+int cdSetLineColor(cdImagePtr im, int lncolor) +(Function)
+
Attribute: Line Colour; Elem Class 5; Elem ID 4
+ Returns 1 for success, 0 for failure. + Sets the line color to lncolor. This should be an integer + which is an index into the color table that you have previously + allocated. + See cdSetLineAttrib for more information + on this and related functions. +
+ +
+int cdSetFillStyle(cdImagePtr im, int instyle) +(Function)
+
Attribute: Interior Style; Elem Class 5; Elem ID 22
+ Returns 1 for success, 0 for failure. + Sets the style of the interior of filled area elements. + instyle is the interior style which is an integer with + possible values of: +
    +
  • 0 for hollow. No filling, but the boundary (bounding line) of the + filled area is drawn using the fill colour currently selected. + The boundary of a "hollow" filled area is considered to be the + representation of the interior. The boundary is distinct from the edge, + and is drawn only for "hollow" filled areas
    • +
  • 1 for solid. Fill the interior using the fill colour currently + selected
    • +
  • 3 for hatch. Fill the interior using the fill colour and hatch index + currently selected.
    • +
  • 4 for empty. No filling is done and no boundary is drawn, i.e., + nothing is done to represent the interior. The only potentially + visible component of an "empty" filled area is the edge, subject + to EDGE VISIBILITY and other edge attributes.
    • +
+ instyle must be one of these values or the function will fail. + So, basically, if you want an interior which is transparent and you can + see what is underneath it, use "empty" otherwise fill it in with a + hatch or solid color. + See cdSetShapeFillAttrib for more + information on this and related functions. +
+ +
+int cdSetFillColor(cdImagePtr im, int incolor) +(Function)
+
Attribute: Fill Colour; Elem Class 5; Elem ID 23
+ Returns 1 for success, 0 for failure. + Sets the fill color to incolor. This should be an integer + which is an index into the color table that you have previously + allocated. + See cdSetShapeFillAttrib for more + information on this and related functions. +
+ +
+int cdSetFillHatch(cdImagePtr im, int inhatch) +(Function)
+
Attribute: Hatch Index; Elem Class 5; Elem ID 24
+ Returns 1 for success, 0 for failure. + Sets the hatch pattern for the interior of filled-area elements to + inhatch. The fill style + must be set to hatch for this to have an effect. the value for + inhatch is the hatch style, which is an integer with possible values + of: +
    +
  • 1 for horizontal lines
    • +
  • 2 for vertcal lines
    • +
  • 3 for positive slope parallel lines
    • +
  • 4 for negative slope parallel lines
    • +
  • 5 for horizontal/vertical crosshatch
    • +
  • 6 for positive/negative slope crosshatch
    • +
+ lntype must be one of these values or the function will fail. + See cdSetShapeFillAttrib for more + information on this and related functions. +
+ +
+int cdSetEdgeType(cdImagePtr im, int edtype) +(Function)
+
Attribute: Edge Type; Elem Class 5; Elem ID 27
+ Returns 1 for success, 0 for failure. + edtype is the edge type which is an integer with possible values + of: +
    +
  • 1 for a solid line
    • +
  • 2 for a dashed line
    • +
  • 3 for a dotted line
    • +
  • 4 for a dash-dot line
    • +
  • 5 for a dash-dot-dot line
    • +
+ edtype must be one of these values or the function will fail. + See cdSetShapeEdgeAttrib for more + information on this and related functions. +
+ +
+int cdSetEdgeWidth(cdImagePtr im, int edwidth) +(Function)
+
Attribute: Edge Width; Elem Class 5; Elem ID 28
+ Returns 1 for success, 0 for failure. + edwidth is an integer giving the width of the perimeter lines. + With an image of height X with line width 1 the displayed width will be 1/X%. + As an example, if you image is x=5, y=10, and you set line width = 1, + and draw a vertical line, the resulting line will cover 20% of + horizontal area. (I think anyway). + See cdSetShapeEdgeAttrib for more + information on this and related functions. +
+ +
+int cdSetEdgeColor(cdImagePtr im, int edcolor) +(Function)
+
Attribute: Edge Color; Elem Class 5; Elem ID 29
+ Returns 1 for success, 0 for failure. + Sets the color of the perimeter lines to edcolor. This + should be an integer which is an index into the color table that + you have previously allocated. + See cdSetShapeEdgeAttrib for more + information on this and related functions. +
+ +
+int cdSetEdgeVis(cdImagePtr im, int edvis) +(Function)
+
Attribute: Edge Visibility; Elem Class 5; Elem ID 30
+ Returns 1 for success, 0 for failure. + edvis is an integer that can have one of the following values. +
    +
  • 0 for invisible edges
    • +
  • 1 for visible edges
    • +
+ If you set the edge visibility to off (invisible edges) than you will + not see the edges, regardless of what other edge attributes are set. + The other attributes will still be set and turning the edge visibility + to on will make edges using the current edge styles. + See cdSetShapeEdgeAttrib for more + information on this and related functions. +
+ +
+ + +

Color handling functions

+ +
+
+int cdImageColorAllocate(cdImagePtr im, int r, int g, int b) +(Function)
+
cdImageColorAllocate finds the first available color index in + the image specified, sets its RGB values to those requested + (255 is the maximum for each), and returns the index of the new color + table entry. When creating a new image, the first time you invoke this + function, you are setting the background color for that image. +

+ In the event that all cdMaxColors colors + (256) have been allocated already, cdImageColorAllocate will return + -1 to indicate failure, otherwise it will return the index into the + color table allocated. (Note that most functions return 0 on failure, but + 0 is a valid color table entry.) +

+ cdImageColorAllocate does not check for existing colors that match + your request, you might want to use + cdImageColorExact prior to calling this + function to keep from defining multiple indexes with the same color. If + color alocation fails, use + cdImageColorClosest to find the + nearest matching color. +

+ +
+int cdImageColorClosest(cdImagePtr im, int r, int g, int b) +(Function)
+
cdImageColorClosest searches the colors which have been + defined thus far in the image specified and returns the + index of the color with RGB values closest to those of the + request. (Closeness is determined by Euclidian distance, + which is used to determine the distance in three-dimensional color + space between colors.) +

+ If no colors have yet been allocated in the image, + gdImageColorClosest returns -1. +

+ This function is most useful as a backup method for choosing + a drawing color when an image already contains + cdMaxColors (256) colors and + no more can be allocated. + See cdImageColorExact + for a method of locating exact matches only. +

+ +
+int cdImageColorExact(cdImagePtr im, int r, int g, int b) +(Function)
+
cdImageColorExact searches the colors which have been + defined thus far in the image specified and returns the + index of the first color with RGB values which exactly + match those of the request. If no allocated color matches the + request precisely, cdImageColorExact returns -1. + See cdImageColorClosest + for a way to find the color closest to the color requested. +
+ +
int cdImageColorsTotal(cdImagePtr im) +(Macro) +
cdImageColorsTotal is a macro which returns the number of + colors currently allocated in the image. Use this macro + to obtain this information; do not access the structure + directly. +
+ +
+int cdImageColorRed(cdImagePtr im, int c) +(Macro) +
cdImageColorRed is a macro which returns the red portion + of the specified color in the image. Use this macro + to obtain this information; do not access the structure + directly. +
+ +
+int cdImageColorGreen(cdImagePtr im, int c) +(Macro) +
cdImageColorGreen is a macro which returns the green portion + of the specified color in the image. Use this macro + to obtain this information; do not access the structure + directly. +
+ +
+int cdImageColorBlue(cdImagePtr im, int c) +(Macro) +
cdImageColorBlue is a macro which returns the green portion + of the specified color in the image. Use this macro + to obtain this information; do not access the structure + directly. +
+ +
+ + +

Constants

+ + +
+
+cdMaxColors +Constant
+
cdMaxColors is the maximum number of colors that can be allocated in + a CGM picture. the CGM standard allows for many different ways of + allocating colors, but I have chosen to limit this library to + 8 bit indexed color. This means the maximum value of this + is 256. If you really wanted to you could make it smaller though it + would not have an effect on the resulting file size. +
+ +
+CDSTARTLISTSIZE +Constant
+
When you create an image, a buffer is allocated to hold the drawing + commands. This is the initial size of the buffer in bytes. When it is + filled, the size gets increased by + CDGROWLISTSIZE. + If you know you are going to be working with very small CGM's then + make this a small number. If you know your CGM's will be large increase + this number. If CDSTARTLISTSIZE is smaller than the header information + than it will have to grow before you do anything. I wouldn't make it + smaller than 1024. Try to make it as large as the average picture you make. +
+ +
+CDGROWLISTSIZE +Constant
+
When you create an image, a buffer is allocated to hold the drawing + commands. When the buffer is filled, the size is increased by the amount + given in CDGROWLISTSIZE (in bytes). If you know that most of the CGM's you + create will be near the size of CDSTARTLISTSIZE + than make this number small. If there is lots of variablility in the + size of your CGM's, make this number large. If CDGROWLISTSIZE is + larger than CDSTARTLISTSIZE, you should probably increase the value + of CDSTARTLISTSIZE. If CDGROWLISTSIZE is smaller than the largest + CGM element you create than it will be growing alot, so I wouldn't + make it smaller than about 1024. +
+ +
+ + +

Using cd instead of gd

+

+CD was designed to be easy to use instead of gd (or with gd, if you want +to be able to produce both). However, There are significate differences +between the way CGM handles attributes versus the way gd does. In particular, +gd requires you to put the line color in the function call to draw lines, +CD does not, Color, like the other attributes only need to be set when +they are changed. I recomend that you read over the documentation of both +to see what the differences are, and make appropriate changes to your +code. If you really want to make as few changes as possible to your +code, I have provided two functions to help you. cdImageLine +takes the same parameters as gdImageLine and will draw +a solid line of the color specified. cdImageRectangle +draws a hollow rectangle with solid edges of the color specified. I +did this by drawing four lines, so it is not a true rectangle. +Again, I recomend you use cdLine and cdRectangle +instead of these, but they are there if you want them. + +

Please tell us you're using cd!

+

+When you contact us and let us know you are using cd, +you help us justify the time spent in maintaining and improving +it. So please let us know. If the results are publicly +visible on the web, a URL is a wonderful thing to receive, but +if it's not a publicly visible project, a simple note is just +as welcome. +

+ + +
+ +G. Edward Johnson
+lorax@nist.gov +
+ diff --git a/src/cd/cd1.2.lsm b/src/cd/cd1.2.lsm new file mode 100644 index 0000000..eaa90e6 --- /dev/null +++ b/src/cd/cd1.2.lsm @@ -0,0 +1,11 @@ +Title: CGMDraw +Version: 1.2 +Entered-date: 28 Jun 1996 +Description: C Library for creating CGM vector graphics files. +Keywords: Computer Graphics Metafile vector CGM +Author: lorax@nist.gov (G. Edward Johnson) +Maintained-by: lorax@nist.gov (G. Edward Johnson) +Primary-site: zing.ncsl.nist.gov /cgm/cd1.2.tar.gz + 34kb +Platforms: Sun, Linux, Ultrix, IRIX, DOS +Copying-policy: Freely Redistributable diff --git a/src/cd/cdmulti.c b/src/cd/cdmulti.c new file mode 100644 index 0000000..cdfeee2 --- /dev/null +++ b/src/cd/cdmulti.c @@ -0,0 +1,98 @@ +/* + * cdmulti is a program to make a cgm file with multiple pictures in it. + * + + cdmulti.c: test program for the cgmdraw module. + + Written by G. Edward Johnson + Date: June 26, 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + +*/ + + +#include +#include +#include +#include +#include +#include "defines.h" +#include "cd.h" + + +int main () { + + /* you must create a pointer to the image(s) that you will be using + * not suprisingly, it is of type cdImagePtr */ + cdImagePtr im; + + /* this is a pointer to the output file you will be using */ + FILE *outf; + + /* these will be index's into the color palette containing + * the corresponding colors */ + int black, white, blue; + + + /* Create an image 200 pixels wide by 250 pixels high */ + im = cdImageCreate(200, 250); + + /* allocate some colors (isn't this fun?) */ + /* the first color allocated is the background color */ + white = cdImageColorAllocate (im, 255,255,255); + black = cdImageColorAllocate(im, 0, 0, 0); + blue = cdImageColorAllocate(im, 0, 0, 255); + + /* set the text attributes */ + /* font, colorindex, and size respectivily */ + + /* font is the style the text is written in. 1 is for Times, + * 5 is for Helvetica. */ + /* we will have black text for this one */ + /* Size is a tough one, but larger numbers give larger text. + * 25 is a not too large size */ + if (!(cdSetTextAttrib(im, 5, black, 25))) return 0; + + + /* Now that we have set some attributes, lets do some drawing */ + + /* lets put some text in the picture. */ + /* (20,100) is the point at the lower left corner of the text */ + if (!(cdText(im, 20, 100, "Hello World"))) return 0; + + + /* Here's something special, put a second picture in the file */ + /* we put in a second picture, and reset all defaults. This means + * we have to re-allocate the colors as well */ + if (!(cdCgmNewPic(im, 0))) return 0; + + /* allocate some colors (Again!) */ + /* the first color allocated is the background color */ + white = cdImageColorAllocate (im, 255,255,255); + black = cdImageColorAllocate(im, 0, 0, 0); + blue = cdImageColorAllocate(im, 0, 0, 255); + /* set text attributes */ + if (!(cdSetTextAttrib(im, 5, black, 25))) return 0; + if (!(cdText(im, 20, 100, "Goodbye World"))) return 0; + + + /* now write the file out. */ + outf = fopen("cdmulti.cgm", "wb"); + if (!outf) return 0; + cdImageCgm(im, outf); + fclose(outf); + outf = 0; + + /* Remember to destroy the image when you are done */ + cdImageDestroy(im); + im = 0; + + printf("I just created a multi picture CGM!!!\n"); + + return 1; + +} diff --git a/src/cd/cdsimple.c b/src/cd/cdsimple.c new file mode 100644 index 0000000..b3ddb40 --- /dev/null +++ b/src/cd/cdsimple.c @@ -0,0 +1,109 @@ +/* + * cdsimple is a very simple program that uses the cd library. + * it will walk you through the basics. + * + + cdsimple.c: test program for the cgmdraw module. + + Written by G. Edward Johnson + Date: April 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + +*/ + + +#include +#include +#include +#include +#include +#include "defines.h" +#include "cd.h" + + +int main () { + + /* you must create a pointer to the image(s) that you will be using + * not suprisingly, it is of type cdImagePtr */ + cdImagePtr im; + + /* this is a pointer to the output file you will be using */ + FILE *outf; + + /* these will be index's into the color palette containing + * the corresponding colors */ + int black, white, blue; + + + /* Create an image 400 pixels wide by 500 pixels high */ + im = cdImageCreate(400, 500); + + /* allocate some colors (isn't this fun?) */ + /* the first color allocated is the background color */ + white = cdImageColorAllocate (im, 255,255,255); + black = cdImageColorAllocate(im, 0, 0, 0); + blue = cdImageColorAllocate(im, 0, 0, 255); + + /* Set the fill attributes */ + /* fill, colorindex, and hatch respectivily */ + /* see the cd documentation for a complete description */ + + /* fill is the color that will be on the inside of filled objects + * such as rectangles and polygons. + * It can be 1 for solid color, 2 for hatch pattern, 4 for empty */ + /* let's use blue for the fill color */ + /* we are going to set it to solid, so the hatch pattern doesn't + * matter. we will signify no change by putting in -1 */ + if (!(cdSetShapeFillAttrib(im, 1, blue, -1))) return 0; + + /* notice that we also checked to make sure the command actually + * worked. */ + + /* we don't want the edges of our shapes to be a different color + * so make them invisible. 0 means invisible, 1 means visible. */ + if (!(cdSetEdgeVis(im, 0))) return 0; + + + /* set the text attributes */ + /* font, colorindex, and size respectivily */ + + /* font is the style the text is written in. 1 is for Times, + * 5 is for Helvetica. */ + /* we will have black text for this one */ + /* Size is a tough one, but larger numbers give larger text. + * 25 is a not too large size */ + if (!(cdSetTextAttrib(im, 5, black, 25))) return 0; + + + + /* Now that we have set some attributes, lets do some drawing */ + + /* Draw a rectangle (10,450) is upper left, (350,350) is lower right */ + if (!(cdRectangle(im, 10, 450, 350, 350))) return 0; + + /* lets put some text in the picture too. */ + /* (100,100) is the point at the lower left corner of the text */ + if (!(cdText(im, 100, 100, "Hello World"))) return 0; + + + + /* now write the file out, lets call it cdsimple.cgm */ + outf = fopen("cdsimple.cgm", "wb"); + if (!outf) return 0; + cdImageCgm(im, outf); + fclose(outf); + outf = 0; + + /* Remember to destroy the image when you are done */ + cdImageDestroy(im); + im = 0; + + printf("I just created a simple CGM!!!\n"); + + return 1; + +} diff --git a/src/cd/cdtest.c b/src/cd/cdtest.c new file mode 100644 index 0000000..e1e697e --- /dev/null +++ b/src/cd/cdtest.c @@ -0,0 +1,425 @@ + +#include +#include +#include +#include +#include +#include "defines.h" +#include "cd.h" + +/* cdtest.c: test program for the cgmdraw module. + + Written by G. Edward Johnson + Date: April 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + +*/ + + +int main () { +cdImagePtr myimage; + + /* Color indexes */ + int white; + int blue; + int red; + int green; + int black; + int lavender; + /* points for polygons and polylines */ + cdPoint points[15]; + /* output file */ + FILE *outf; + + +/* create an image, 1000 by 1000 pixels */ +myimage = cdImageCreate(1000, 1000); + +/* Allocate the background color */ +white = cdImageColorAllocate (myimage, 255,255,255); + red = cdImageColorAllocate(myimage, 255, 0, 0); + green = cdImageColorAllocate(myimage, 0, 255, 0); + blue = cdImageColorAllocate(myimage, 0, 0, 255); + black = cdImageColorAllocate(myimage, 0, 0, 0); + +if (cdSetLineColor(myimage, blue)) { + fprintf(stderr, "cdSetLineColor Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineColor Unsuccessfull\n"); +} + +if (cdSetLineColor(myimage, blue)) { + fprintf(stderr, "cdSetLineColor Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineColor Unsuccessfull\n"); +} + + +if (cdImageLine(myimage, 400, 8, 520, 8, green)) { + fprintf(stderr, "cdImageLine Successfull\n"); +} +else { + fprintf(stderr, "cdImageLine Unsuccessfull\n"); +} + +if (cdImageLine(myimage, 50, 50, 500, 500, red)) { + fprintf(stderr, "cdImageLine Successfull\n"); +} +else { + fprintf(stderr, "cdImageLine Unsuccessfull\n"); +} + +if (cdSetLineAttrib(myimage, 2, 3, red)) { + fprintf(stderr, "cdSetLineAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineAttrib Unsuccessfull\n"); +} + +if (cdLine(myimage, 500, 50, 50, 500)) { + fprintf(stderr, "cdLine Successfull\n"); +} +else { + fprintf(stderr, "cdLine Unsuccessfull\n"); +} + +/* Now, build a rectangle */ +if (cdSetShapeFillAttrib(myimage, 3, blue, 6 )) { + fprintf(stderr, "cdSetShapeFillAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetShapeFillAttrib Unsuccessfull\n"); +} + +if (cdSetShapeEdgeAttrib(myimage, 1, 2, green, 1 )) { + fprintf(stderr, "cdSetShapeEdgeAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetShapeEdgeAttrib Unsuccessfull\n"); +} + +if (cdRectangle(myimage, 100, 100, 250, 250 )) { + fprintf(stderr, "cdRectangle Successfull\n"); +} +else { + fprintf(stderr, "cdRectangle Unsuccessfull\n"); +} + + + +/* now check out each of the line styles in order */ + +if (cdSetLineAttrib(myimage, 5, 4, green)) { + fprintf(stderr, "cdSetLineAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineAttrib Unsuccessfull\n"); +} + +if (cdLine(myimage, 100, 600, 500, 600)) { + fprintf(stderr, "cdLine Successfull\n"); +} +else { + fprintf(stderr, "cdLine Unsuccessfull\n"); +} + +if (cdSetLineAttrib(myimage, 4, -1, -1)) { + fprintf(stderr, "cdSetLineAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineAttrib Unsuccessfull\n"); +} +if (cdLine(myimage, 100, 625, 500, 625)) { + fprintf(stderr, "cdLine Successfull\n"); +} +else { + fprintf(stderr, "cdLine Unsuccessfull\n"); +} + +if (cdSetLineAttrib(myimage, 3, -1, -1)) { + fprintf(stderr, "cdSetLineAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineAttrib Unsuccessfull\n"); +} +if (cdLine(myimage, 100, 650, 500, 650)) { + fprintf(stderr, "cdLine Successfull\n"); +} +else { + fprintf(stderr, "cdLine Unsuccessfull\n"); +} + + +if (cdSetLineAttrib(myimage, 2, -1, -1)) { + fprintf(stderr, "cdSetLineAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineAttrib Unsuccessfull\n"); +} +if (cdLine(myimage, 100, 675, 500, 675)) { + fprintf(stderr, "cdLine Successfull\n"); +} +else { + fprintf(stderr, "cdLine Unsuccessfull\n"); +} + +if (cdSetLineAttrib(myimage, 1, -1, -1)) { + fprintf(stderr, "cdSetLineAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineAttrib Unsuccessfull\n"); +} +if (cdLine(myimage, 100, 700, 500, 700)) { + fprintf(stderr, "cdLine Successfull\n"); +} +else { + fprintf(stderr, "cdLine Unsuccessfull\n"); +} + +/* now make a circle */ +if (cdSetShapeFillAttrib(myimage, 1, -1, 6 )) { + fprintf(stderr, "cdSetShapeFillAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetShapeFillAttrib Unsuccessfull\n"); +} + +if (cdSetShapeEdgeAttrib(myimage, 1, 2, green, 0 )) { + fprintf(stderr, "cdSetShapeEdgeAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetShapeEdgeAttrib Unsuccessfull\n"); +} + +if (cdCircle(myimage, 500, 500, 25)) { + fprintf(stderr, "cdCircle Successfull\n"); +} +else { + fprintf(stderr, "cdCircle Unsuccessfull\n"); +} + +/* how about a Circular Arc now */ +if (cdArc3Pt(myimage, 550, 500, 600, 600, 650, 550 )) { + fprintf(stderr, "cdArc3Pt Successfull\n"); +} +else { + fprintf(stderr, "cdArc3Pt Unsuccessfull\n"); +} + +/* now draw a closed Circular Arc */ +if (cdArc3PtClose(myimage, 550, 200, 600, 300, 650, 250, 0 )) { + fprintf(stderr, "cdArc3PtClose Successfull\n"); +} +else { + fprintf(stderr, "cdArc3PtClose Unsuccessfull\n"); +} + +/* and now for an ellipse */ +if (cdSetShapeEdgeAttrib(myimage, 1, 2, green, 1 )) { + fprintf(stderr, "cdSetShapeEdgeAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetShapeEdgeAttrib Unsuccessfull\n"); +} + +if (cdEllipse(myimage, 750, 200, 800, 250, 750, 300 )) { + fprintf(stderr, "cdEllipse Successfull\n"); +} +else { + fprintf(stderr, "cdEllipse Unsuccessfull\n"); +} + + +/* Now, the harder ones. First lets try the polygon stuff */ +/* a polygon with 7 or less points */ + +points[0].x = 700; +points[0].y = 700; +points[1].x = 725; +points[1].y = 750; +points[2].x = 775; +points[2].y = 650; + +if (cdPolygon(myimage, points, 3)) { + fprintf(stderr, "cdPolygon Successfull\n"); +} +else { + fprintf(stderr, "cdPolygon Unsuccessfull\n"); +} + +/* Here's a tough one, a polygon with more than seven points */ + +points[0].x = 100; +points[0].y = 100; + +points[1].x = 100; +points[1].y = 400; + +points[2].x = 400; +points[2].y = 400; + +points[3].x = 400; +points[3].y = 100; + +points[4].x = 100; +points[4].y = 100; + +points[5].x = 200; +points[5].y = 200; + +points[6].x = 200; +points[6].y = 300; + +points[7].x = 300; +points[7].y = 300; + +points[8].x = 300; +points[8].y = 200; + +points[9].x = 200; +points[9].y = 200; + +points[10].x = 100; +points[10].y = 100; + +if (cdPolygon(myimage, points, 11)) { + fprintf(stderr, "cdPolygon Successfull\n"); +} +else { + fprintf(stderr, "cdPolygon Unsuccessfull\n"); +} + + +/* now for poly lines, just like polygons (except they're lines) */ + +if (cdSetLineAttrib(myimage, 1, 1, red)) { + fprintf(stderr, "cdSetLineAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetLineAttrib Unsuccessfull\n"); +} + + +points[0].x = 400; +points[0].y = 16; +points[1].x = 520; +points[1].y = 16; +if (cdPolyLine(myimage, points, 2)) { + fprintf(stderr, "cdPolyLine Successfull\n"); +} +else { + fprintf(stderr, "cdPolyLine Unsuccessfull\n"); +} + +points[0].x = 800; +points[0].y = 650; +points[1].x = 825; +points[1].y = 675; +points[2].x = 850; +points[2].y = 650; +points[3].x = 875; +points[3].y = 700; +if (cdPolyLine(myimage, points, 4)) { + fprintf(stderr, "cdPolyLine Successfull\n"); +} +else { + fprintf(stderr, "cdPolyLine Unsuccessfull\n"); +} + + +/* Hey, things are going so well, lets do some text */ +lavender = cdImageColorAllocate(myimage, 204, 102, 255); + +if (cdSetTextAttrib(myimage, 1, lavender, 50)) { + fprintf(stderr, "cdSetTextAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetTextAttrib Unsuccessfull\n"); +} + +if (cdText(myimage, 50, 800, "CGM Draw Version 1.2")) { + fprintf(stderr, "cdText Successfull\n"); +} +else { + fprintf(stderr, "cdText Unsuccessfull\n"); +} + +/* More text. This time test TextPath and TextOrient */ +if (cdSetTextPath(myimage, 3)) { + fprintf(stderr, "cdSetTextPath Successfull\n"); +} +else { + fprintf(stderr, "cdSetTextPath Unsuccessfull\n"); +} + +if (cdText(myimage, 50, 800, "CGM Draw")) { + fprintf(stderr, "cdText Successfull\n"); +} +else { + fprintf(stderr, "cdText Unsuccessfull\n"); +} + +if (cdSetTextOrient(myimage, 1, 0, 0, -1)) { + fprintf(stderr, "cdSetTextOrient Successfull\n"); +} +else { + fprintf(stderr, "cdSetTextOrient Unsuccessfull\n"); +} + +if (cdSetTextPath(myimage, 0)) { + fprintf(stderr, "cdSetTextPath Successfull\n"); +} +else { + fprintf(stderr, "cdSetTextPath Unsuccessfull\n"); +} + +if (cdText(myimage, 950, 400, "CGM Draw")) { + fprintf(stderr, "cdText Successfull\n"); +} +else { + fprintf(stderr, "cdText Unsuccessfull\n"); +} + + +if (cdSetTextOrient(myimage, 0, 1, 1, 0)) { + fprintf(stderr, "cdSetTextOrient Successfull\n"); +} +else { + fprintf(stderr, "cdSetTextOrient Unsuccessfull\n"); +} + + +if (cdSetTextAttrib(myimage, 5, -1, 25)) { + fprintf(stderr, "cdSetTextAttrib Successfull\n"); +} +else { + fprintf(stderr, "cdSetTextAttrib Unsuccessfull\n"); +} + +if (cdText(myimage, 5, 5, "G. Edward Johnson")) { + fprintf(stderr, "cdText Successfull\n"); +} +else { + fprintf(stderr, "cdText Unsuccessfull\n"); +} + + + + +outf = fopen("cdout.cgm", "wb"); +if (!outf) return 0; +cdImageCgm(myimage, outf); +fclose(outf); +outf = 0; + +cdImageDestroy(myimage); + + +return 1; +} diff --git a/src/cd/cdtext.c b/src/cd/cdtext.c new file mode 100644 index 0000000..c540a69 --- /dev/null +++ b/src/cd/cdtext.c @@ -0,0 +1,135 @@ +/* + * cdtext is an example program that uses the text attribute commands + * cdSetTextPath and cdSetTextOrient + * + + cdtext.c: test program for the cgmdraw module. + + Written by G. Edward Johnson + Date: May 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + +*/ + + +#include +#include +#include +#include +#include +#include "defines.h" +#include "cd.h" + + +int main () { + + /* you must create a pointer to the image(s) that you will be using + * not suprisingly, it is of type cdImagePtr */ + cdImagePtr im; + + /* this is a pointer to the output file you will be using */ + FILE *outf; + + /* these will be index's into the color palette containing + * the corresponding colors */ + int black, white, blue; + + + /* Create an image 800 pixels wide by 400 pixels high */ + im = cdImageCreate(800, 400); + + /* allocate some colors (isn't this fun?) */ + /* the first color allocated is the background color */ + white = cdImageColorAllocate (im, 255,255,255); + black = cdImageColorAllocate(im, 0, 0, 0); + blue = cdImageColorAllocate(im, 0, 0, 255); + + + /* set the text attributes */ + /* font, colorindex, and size respectivily */ + + /* font is the style the text is written in. 1 is for Times, + * 5 is for Helvetica. */ + /* we will have black text for this one */ + /* Size is a tough one, but larger numbers give larger text. + */ + if (!(cdSetTextAttrib(im, 5, black, 20))) return 0; + + /* Set some line attributes, lets make lines solid, width 1, and blue + */ + if (!(cdSetLineAttrib(im, 1, 1, blue))) return 0; + + /* Draw a couple of grid lines */ + if (!(cdLine(im, 0,200,799,200))) return 0; + if (!(cdLine(im, 200,0,200,399))) return 0; + if (!(cdLine(im, 600,0,600,399))) return 0; + + + /* Show Text going left, up, down, and right, all starting + * from the same point */ + + /* Text going to the left */ + if (!(cdSetTextPath(im, 1))) return 0; + if (!(cdText(im, 200, 200, "Text Left"))) return 0; + + /* Text going UP */ + if (!(cdSetTextPath(im, 2))) return 0; + if (!(cdText(im, 200, 200, "Text Up"))) return 0; + + /* Text going DOWN */ + if (!(cdSetTextPath(im, 3))) return 0; + if (!(cdText(im, 200, 200, "Text Down"))) return 0; + + /* Text going to the RIGHT */ + if (!(cdSetTextPath(im, 0))) return 0; + if (!(cdText(im, 200, 200, "Text Right"))) return 0; + + /* Show text going at an angle of 0, 45, 90, 135, 180 Degrees + */ + + /* Text at no angle */ + if (!(cdText(im, 600, 200, "CGM Draw"))) return 0; + + /* Text, 45 Degree Angle */ + if (!(cdSetTextOrient(im, -1, 1, 1, 1))) return 0; + if (!(cdText(im, 600, 200, "CGM Draw"))) return 0; + + /* Text, 90 Degree Angle */ + if (!(cdSetTextOrient(im, -1, 0, 0, 1))) return 0; + if (!(cdText(im, 600, 200, "CGM Draw"))) return 0; + + /* Text, 135 Degree Angle */ + if (!(cdSetTextOrient(im, -1, -1, -1, 1))) return 0; + if (!(cdText(im, 600, 200, "CGM Draw"))) return 0; + + /* Text, 180 Degree Angle */ + if (!(cdSetTextOrient(im, 0, -1, -1, 0))) return 0; + if (!(cdText(im, 600, 200, "CGM Draw"))) return 0; + + /* reset the text to 0 angle */ + if (!(cdSetTextOrient(im, 0, 1, 1, 0))) return 0; + + + if (!(cdSetTextAttrib(im, 5, -1, -1))) return 0; + if (!(cdText(im, 5, 5, "G. Edward Johnson"))) return 0; + + /* now write the file out, lets call it cdtext.cgm */ + outf = fopen("cdtext.cgm", "wb"); + if (!outf) return 0; + cdImageCgm(im, outf); + fclose(outf); + outf = 0; + + /* Remember to destroy the image when you are done */ + cdImageDestroy(im); + im = 0; + + printf("CGM Text Example!!!\n"); + + return 1; + +} diff --git a/src/cd/color16.c b/src/cd/color16.c new file mode 100644 index 0000000..ca7e454 --- /dev/null +++ b/src/cd/color16.c @@ -0,0 +1,186 @@ +/* + * Color16 is a test program that is part of the CGM Draw Library. + * It Will write out a CGM file that allocates a 16 color pallete + * using the function cdImageColor16. These correspond to the 16 + * standard Windows colors. + * + + color16.c: test program for the cgmdraw module. + + Written by G. Edward Johnson + Date: April 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + +*/ + + +#include +#include +#include +#include +#include +#include "defines.h" +#include "cd.h" + + +int main () { + cdImagePtr im; + FILE *outf; + + + /* Create an image 500 pixels high by 400 pixels wide */ + im = cdImageCreate(400, 500); + + /* allocate the 16 windows colors */ + if (!(cdImageColor16(im))) return 0; + + /* Set the fill attributes */ + /* fill=solid, colorindex=0, hatch=no change */ + if (!(cdSetShapeFillAttrib(im, 1, 0, -1))) return 0; + + /* set the text attributes */ + /* font=helvetica, colorindex=1, size=25 */ + if (!(cdSetTextAttrib(im, 5, 1, 25))) return 0; + + /* The first color index is white, so lets draw a box around it */ + /* edge=solid, width=1, color=1 (black), visible=yes */ + cdSetShapeEdgeAttrib(im, 1, 1, 1, 1); + + + /* Draw a rectangle (10,450) is upper left, (35,425) is lower right */ + if (!(cdRectangle(im, 10, 450, 35, 425))) return 0; + /* Label it */ + if (!(cdText(im, 40, 425, "Color Index: 0"))) return 0; + + /* Make the edges invisible */ + if (!(cdSetEdgeVis(im, 0))) return 0; + + + /* Set the fill color */ + if (!(cdSetFillColor(im, 1))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 10, 400, 35, 375))) return 0; + /* Label it */ + if (!(cdText(im, 40, 375, "Color Index: 1"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 2))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 10, 350, 35, 325))) return 0; + /* Label it */ + if (!(cdText(im, 40, 325, "Color Index: 2"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 3))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 10, 300, 35, 275))) return 0; + /* Label it */ + if (!(cdText(im, 40, 275, "Color Index: 3"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 4))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 10, 250, 35, 225))) return 0; + /* Label it */ + if (!(cdText(im, 40, 225, "Color Index: 4"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 5))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 10, 200, 35, 175))) return 0; + /* Label it */ + if (!(cdText(im, 40, 175, "Color Index: 5"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 6))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 10, 150, 35, 125))) return 0; + /* Label it */ + if (!(cdText(im, 40, 125, "Color Index: 6"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 7))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 10, 100, 35, 75))) return 0; + /* Label it */ + if (!(cdText(im, 40, 75, "Color Index: 7"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 8))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 450, 235, 425))) return 0; + /* Label it */ + if (!(cdText(im, 240, 425, "Color Index: 8"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 9))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 400, 235, 375))) return 0; + /* Label it */ + if (!(cdText(im, 240, 375, "Color Index: 9"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 10))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 350, 235, 325))) return 0; + /* Label it */ + if (!(cdText(im, 240, 325, "Color Index: 10"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 11))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 300, 235, 275))) return 0; + /* Label it */ + if (!(cdText(im, 240, 275, "Color Index: 11"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 12))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 250, 235, 225))) return 0; + /* Label it */ + if (!(cdText(im, 240, 225, "Color Index: 12"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 13))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 200, 235, 175))) return 0; + /* Label it */ + if (!(cdText(im, 240, 175, "Color Index: 13"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 14))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 150, 235, 125))) return 0; + /* Label it */ + if (!(cdText(im, 240, 125, "Color Index: 14"))) return 0; + + /* Set the fill color */ + if (!(cdSetFillColor(im, 15))) return 0; + /* Draw a rectangle */ + if (!(cdRectangle(im, 210, 100, 235, 75))) return 0; + /* Label it */ + if (!(cdText(im, 240, 75, "Color Index: 15"))) return 0; + + /* now put a little thing at the bottom of the picture */ + if (!cdText(im, 5, 10, "Colors allocated by cdImageColor16")) return 0; + + /* now write the file out, lets call it color16.cgm */ + outf = fopen("color16.cgm", "wb"); + if (!outf) return 0; + cdImageCgm(im, outf); + fclose(outf); + outf = 0; + + /* Remember to destroy the image when you are done */ + cdImageDestroy(im); + im = 0; + + printf("CGM with 16 color colortable generated as color16.cgm\n"); + + return 1; + +} diff --git a/src/cd/defines.h b/src/cd/defines.h new file mode 100644 index 0000000..7ee5494 --- /dev/null +++ b/src/cd/defines.h @@ -0,0 +1,55 @@ + +/* defines.h: declarations file for the cgmdraw module. + + Written by G. Edward Johnson + Date: April 1996 + Copyright: cd software produced by NIST, an agency of the + U.S. government, is by statute not subject to copyright + in the United States. Recipients of this software assume all + responsibilities associated with its operation, modification + and maintenance. + +*/ + +#ifndef CDDEF_H +#define CDDEF_H 1 + +#define b0 01 +#define b1 02 +#define b2 04 +#define b3 010 +#define b4 020 +#define b5 040 +#define b6 0100 +#define b7 0200 +#define b8 0400 +#define b9 01000 +#define b10 02000 +#define b11 04000 +#define b12 010000 +#define b13 020000 +#define b14 040000 +#define b15 0100000 + +/* Defines the default values for different attributes. In general, + * these track the CGM specificaition, so changing them is not a good idea. + * however, it is generally ok to set them to -1 (undefined) if you want. + */ + +#define CDLTYPE 1 +#define CDLWIDTH 0 +#define CDLCOLOR 1 +#define CDSHAPESTYLE -1 +#define CDSHAPECOLOR 1 +#define CDSHAPEHATCH 1 +#define CDEDGETYPE 1 +#define CDEDGECOLOR -1 +#define CDEDGEWIDTH -1 +#define CDEDGEVIS -1 +#define CDTEXTCOLOR 1 +#define CDTEXTHEIGHT -1 +#define CDTEXTFONT 1 +#define CDTEXTPATH 0 + + +#endif diff --git a/src/cd/makefile.bor b/src/cd/makefile.bor new file mode 100644 index 0000000..bcb95f0 --- /dev/null +++ b/src/cd/makefile.bor @@ -0,0 +1,51 @@ +# Makefile for CGM Draw by G. Edward Johnson +# You may need to modify this makefile +# contributed by Wolfgang Glunz + +CC=tcc +#AR=ar +#CFLAGS= -pedantic -O2 +CFLAGS= +#LIBS=-L./ -lcd +LIBS=cd.obj + +all: cd.obj cdtest.exe color16.exe cdsimple.exe cdtext.exe cdmulti.exe + cdtest; + color16; + cdsimple; + cdtext; + cdmulti; + +libcd.a: cd.h defines.h cd.obj + rm -f libcd.a + $(AR) rc libcd.a cd.obj + +cd.obj: cd.c cd.h defines.h + $(CC) $(CFLAGS) -c cd.c + +testmain.obj: testmain.c cd.h defines.h + $(CC) $(CFLAGS) -c testmain.c + +color16.obj: color16.c cd.h defines.h + $(CC) $(CFLAGS) -c color16.c + +cdsimple.obj: cdsimple.c cd.h defines.h + $(CC) $(CFLAGS) -c cdsimple.c + +cdsimple.exe: cdsimple.obj cd.obj + $(CC) cdsimple.obj $(LIBS) + +color16.exe: color16.obj cd.obj + $(CC) color16.obj $(LIBS) + +cdtest.exe: cdtest.obj cd.obj + $(CC) cdtest.obj $(LIBS) + +cdtext.exe: cdtext.obj cd.obj + $(CC) cdtext.obj $(LIBS) + +cdmulti.exe: cdmulti.obj cd.obj + $(CC) cdmulti.obj $(LIBS) +clean: + del *.obj *.a cdtest.exe color16.exe cdsimple.exe cdtext.exe cdmulti.exe + diff --git a/src/cd/readme b/src/cd/readme new file mode 100644 index 0000000..c1944f3 --- /dev/null +++ b/src/cd/readme @@ -0,0 +1,52 @@ + + +Welcome, and thanks for downloading CGM Draw, a package for creating +CGM files from a "C" program. If you are reading this then you probably +have already unpacked the distribution. You can make it by typing +"make all" this will make libcd.a the cd library, as well as two +example programs, cdtest and color16. Please read over the documentation +in cd.html before using the package. + +Every effort has been made to ensure that the generated cgm files +conform to the standard, however, if you do not use the library +properly, you could generate invalid metafiles that no one is able +to read, so be careful. + +Documentation for cd is included with the package, and is available from +http://speckle.ncsl.nist.gov/~lorax/cgm/cd.html +General information about CGM is available many places on the web, including +http://speckle.ncsl.nist.gov/~lsr/cgm.htm +This distribution may be retrieved via ftp from +zing.ncsl.nist.gov in the directory "cgm" it will have the +name cd followed by the version number. + +I have tested CGM Draw on Solaris, Ultrix, Linux, and IRIX. It +should compile and run on just about any Unix system, and probably +other systems as well. + +Copyright: + +CGM Draw software produced by NIST, an agency of the U.S. government, +is by statute not subject to copyright in the United States. +Recipients of this software assume all responsibilities associated with +its operation, modification and maintenance. Please note however, +that some of the code in this package is from gd, which is copyright. +gd's copyright is as follows: +gd 1.2 is copyright 1994, 1995, Quest Protein Database Center, +Cold Spring Harbor Labs. Permission granted to copy and distribute +this work provided that this notice remains intact. Credit +for the library must be given to the Quest Protein Database Center, +Cold Spring Harbor Labs, in all derived works. This does not +affect your ownership of the derived work itself, and the intent +is to assure proper credit for Quest, not to interfere with your +use of gd. If you have questions, ask. ("Derived works" +includes all programs that utilize the library. Credit must +be given in user-visible documentation.) + + +If you have any questions or comments, please send me e-mail, lorax@nist.gov + +Thanks for trying it out. + Edward Johnson + + -- cgit v1.2.3