First commit - moving from LuaForge to SourceForge

21 files changed, 7905 insertions, 0 deletions

diff --git a/src/intcgm/bparse.c b/src/intcgm/bparse.c
new file mode 100644
index 0000000..ad08179
--- /dev/null
+++ b/src/intcgm/bparse.c
@@ -0,0 +1,1660 @@
+#include <stdio.h>      /* FILE, ftell, fseek, fputc, fopen, fclose, fputs, fprintf */
+#include <string.h>     /* strlen, strncpy */
+#include <stdlib.h>     /* malloc, free */
+#include "cd.h"
+#include "cdcgm.h"
+#include "list.h"
+#include "types.h"
+#include "bparse.h"
+#include "intcgm.h"
+#include "intcgm2.h"
+#include "intcgm4.h"
+#include "intcgm6.h"
+
+/*********************
+* Delimiter elements *
+*********************/
+
+int cgmb_noop ( void )
+{
+ return 0;
+}
+
+int cgmb_begmtf ( void )
+{
+ char *header = NULL;
+
+ if ( intcgm_cgm.len )
+  {
+   if ( cgmb_s ( &header ) ) return 1;
+  }
+
+ if (cdcgmbegmtfcb)
+  {
+   int err;
+   err = cdcgmbegmtfcb ( intcgm_canvas, &intcgm_view_xmin, &intcgm_view_ymin, &intcgm_view_xmax, &intcgm_view_ymax );
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+ return 0;
+} 
+
+int cgmb_endmtf ( void )
+{
+ return 0;
+}
+
+int cgmb_begpic ( void )
+{
+ char *s = NULL;
+ 
+ if ( intcgm_cgm.first )
+   intcgm_cgm.first = 0;
+ else
+   cdCanvasFlush(intcgm_canvas);
+                 
+ if ( intcgm_color_table==NULL )
+  {
+   if ( intcgm_cgm.max_cix < 1 ) intcgm_cgm.max_cix = 1;
+
+   intcgm_color_table = (trgb *) malloc ( sizeof(trgb)*(intcgm_cgm.max_cix+1) );
+
+   intcgm_color_table[0].red   = 255;
+   intcgm_color_table[0].green = 255;
+   intcgm_color_table[0].blue  = 255;
+   intcgm_color_table[1].red   = 0;
+   intcgm_color_table[1].green = 0;
+   intcgm_color_table[1].blue  = 0;
+  }
+
+ cdCanvasClip(intcgm_canvas, CD_CLIPAREA);
+   
+ if ( cgmb_s ( &s ) ) return 1;
+
+ if (cdcgmbegpictcb)
+  {
+   int err;
+   err = cdcgmbegpictcb ( intcgm_canvas, s );
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+ return 0;
+}
+
+int cgmb_begpib ( void )
+{
+ if (cdcgmbegpictbcb)
+  {
+   int err;
+   err = cdcgmbegpictbcb ( intcgm_canvas, 1., 1., intcgm_scale_factor_x, intcgm_scale_factor_y,
+	                         intcgm_scale_factor_mm_x*intcgm_cgm.scaling_mode.scale_factor,
+	                         intcgm_scale_factor_mm_y*intcgm_cgm.scaling_mode.scale_factor,
+						               intcgm_cgm.drawing_mode,
+						               intcgm_vdc_ext.xmin, intcgm_vdc_ext.ymin, intcgm_vdc_ext.xmax, intcgm_vdc_ext.ymax );
+
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+ if (cdcgmsizecb)
+  {
+   int err, w, h;
+   double w_mm=0., h_mm=0.;
+
+   w = intcgm_view_xmax-intcgm_view_xmin+1;
+   h = intcgm_view_ymax-intcgm_view_ymin+1;
+
+   if ( intcgm_cgm.vdc_type==INTEGER )
+    {
+	 w = (int) (intcgm_cgm.vdc_ext.second.x - intcgm_cgm.vdc_ext.first.x);
+	 h = (int) (intcgm_cgm.vdc_ext.second.y - intcgm_cgm.vdc_ext.first.y);
+	 if ( intcgm_cgm.scaling_mode.mode==METRIC )
+	  {
+	   w_mm = w * intcgm_cgm.scaling_mode.scale_factor;
+	   h_mm = h * intcgm_cgm.scaling_mode.scale_factor;
+	  }
+	}
+   else
+    {
+	 if ( intcgm_cgm.scaling_mode.mode==METRIC )
+	  {
+	   w_mm = (intcgm_cgm.vdc_ext.second.x - intcgm_cgm.vdc_ext.first.x) * intcgm_cgm.scaling_mode.scale_factor;
+	   h_mm = (intcgm_cgm.vdc_ext.second.y - intcgm_cgm.vdc_ext.first.y) * intcgm_cgm.scaling_mode.scale_factor;
+	  }
+	}
+
+   err = cdcgmsizecb ( intcgm_canvas, w, h, w_mm, h_mm );
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+ return 0;
+}
+
+int cgmb_endpic ( void )
+{
+ return 0;
+}
+
+/*******************************
+* Metafile Descriptor Elements *
+*******************************/
+
+int cgmb_mtfver ( void )
+{
+ long version;
+
+ if ( cgmb_i ( &version ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_mtfdsc ( void )
+{
+ char *s = NULL;
+
+ if ( cgmb_s ( &s ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_vdctyp ( void )
+{
+ if ( cgmb_e   ( &(intcgm_cgm.vdc_type) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_intpre ( void )
+{
+ long prec;
+
+ if ( cgmb_i ( &prec ) ) return 1;
+
+ if ( prec==8 ) intcgm_cgm.int_prec.b_prec = 0;
+ else if ( prec==16 )  intcgm_cgm.int_prec.b_prec = 1; 
+ else if ( prec==24 )  intcgm_cgm.int_prec.b_prec = 2; 
+ else if ( prec==32 )  intcgm_cgm.int_prec.b_prec = 3; 
+
+ return 0;
+}
+
+int cgmb_realpr ( void )
+{
+ short mode, i1;
+ long i2, i3;
+
+ if ( cgmb_e ( &i1 ) ) return 1;
+ if ( cgmb_i ( &i2 ) ) return 1;
+ if ( cgmb_i ( &i3 ) ) return 1;
+
+ if ( i1 == 0 && i2 == 9 && i3 == 23 ) mode = 0;
+ else if ( i1 == 0 && i2 == 12 && i3 == 52 ) mode = 1;
+ else if ( i1 == 1 && i2 == 16 && i3 == 16 ) mode = 2;
+ else if ( i1 == 1 && i2 == 32 && i3 == 32 ) mode = 3;
+
+ intcgm_cgm.real_prec.b_prec = mode;
+
+ return 0;
+}
+
+int cgmb_indpre ( void )
+{
+ long prec;
+
+ if ( cgmb_i ( &prec ) ) return 1;
+
+ if ( prec==8 ) intcgm_cgm.ix_prec.b_prec = 0;
+ else if ( prec==16 ) intcgm_cgm.ix_prec.b_prec = 1;
+ else if ( prec==24 ) intcgm_cgm.ix_prec.b_prec = 2;
+ else if ( prec==32 ) intcgm_cgm.ix_prec.b_prec = 3;
+
+ return 0;
+}
+
+int cgmb_colpre ( void )
+{
+ long prec;
+
+ if ( cgmb_i ( &prec ) ) return 1;
+
+ if ( prec==8 ) intcgm_cgm.cd_prec = 0;
+ else if ( prec==16 ) intcgm_cgm.cd_prec = 1;
+ else if ( prec==24 ) intcgm_cgm.cd_prec = 2;
+ else if ( prec==32 ) intcgm_cgm.cd_prec = 3;
+
+ return 0;
+}
+
+int cgmb_colipr ( void )
+{
+ long prec;
+
+ if ( cgmb_i ( &prec ) ) return 1;
+
+ if ( prec==8 ) intcgm_cgm.cix_prec = 0;
+ else if ( prec==16 ) intcgm_cgm.cix_prec = 1;
+ else if ( prec==24 ) intcgm_cgm.cix_prec = 2;
+ else if ( prec==32 ) intcgm_cgm.cix_prec = 3;
+
+ return 0;
+}
+
+int cgmb_maxcoi ( void )
+{
+ if ( cgmb_ci ( (unsigned long *)&(intcgm_cgm.max_cix) ) ) return 1;
+
+ intcgm_color_table = (trgb *) realloc ( intcgm_color_table, sizeof(trgb)*(intcgm_cgm.max_cix+1) );
+
+ intcgm_color_table[0].red   = 255;
+ intcgm_color_table[0].green = 255;
+ intcgm_color_table[0].blue  = 255;
+ intcgm_color_table[1].red   = 0;
+ intcgm_color_table[1].green = 0;
+ intcgm_color_table[1].blue  = 0;
+
+ return 0;
+}
+
+int cgmb_covaex ( void )
+{
+ if ( cgmb_rgb   ( &(intcgm_cgm.color_ext.black.red), &(intcgm_cgm.color_ext.black.green), &(intcgm_cgm.color_ext.black.blue) ) ) return 1;
+ if ( cgmb_rgb   ( &(intcgm_cgm.color_ext.white.red), &(intcgm_cgm.color_ext.white.green), &(intcgm_cgm.color_ext.white.blue) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_mtfell ( void )
+{
+ long group, element;
+ long n, i;
+
+ if ( cgmb_i ( &n ) ) return 1;
+
+ for ( i=0; i<n; i++ )
+   {
+    if ( cgmb_ix ( &group ) ) return 1;
+    if ( cgmb_ix ( &element ) ) return 1;
+   }
+
+ return 0;
+}
+
+int cgmb_bmtfdf ( void )
+{
+ int c, id, len, cont, totbc; 
+ unsigned short b;
+ int count=0;
+ int old_cgmlen;
+ char *buff;
+
+ buff = (char *) malloc ( sizeof(char)*intcgm_cgm.len );
+
+ memcpy ( buff, intcgm_cgm.buff.dados, intcgm_cgm.len );
+
+ old_cgmlen = intcgm_cgm.len;
+
+ totbc = 0;
+
+ while ( count<old_cgmlen )
+  {
+   intcgm_cgm.bc = 0;
+
+   b = ((unsigned char)buff[count] << 8) | (unsigned char)buff[count+1];
+   count += 2;
+
+   intcgm_cgm.bl += 2;
+
+   len = b & 0x001F;
+
+   id = ( b & 0x0FE0 ) >> 5;
+
+   c = ( b & 0xF000 ) >> 12;
+
+   cont = 0;
+
+   if ( len > 30 )
+    {
+     b = ((unsigned char)buff[count] << 8) | (unsigned char)buff[count+1];
+     count += 2;
+
+     intcgm_cgm.bl += 2;
+
+     len = b & 0x7FFF;
+     cont = ( b & 0x8000 );
+    }
+
+   intcgm_cgm.len = len;
+
+   if ( intcgm_cgm.len )
+    {
+     if ( intcgm_cgm.len>intcgm_cgm.buff.size )
+       intcgm_cgm.buff.dados = (char *) realloc ( (char *)intcgm_cgm.buff.dados, sizeof(char) * intcgm_cgm.len );
+
+     memcpy ( intcgm_cgm.buff.dados, &buff[count], intcgm_cgm.len );
+	   count += intcgm_cgm.len;
+
+     intcgm_cgm.bl += intcgm_cgm.len;
+
+     if ( len & 1 )
+      {
+       count++;
+       intcgm_cgm.bl += 1;
+      }
+    
+     while ( cont )
+      {
+       unsigned short b;
+       int old_len = intcgm_cgm.len;
+
+       intcgm_cgm.bl += 2;
+
+       b = ((unsigned char)buff[count] << 8) | (unsigned char)buff[count+1];
+       count += 2;
+
+       cont = ( b & 0x8000 );
+
+       len = b & 0x7fff;
+
+       intcgm_cgm.len += len;
+
+       if ( intcgm_cgm.len>intcgm_cgm.buff.size )
+        intcgm_cgm.buff.dados = (char *) realloc ( (char *)intcgm_cgm.buff.dados, sizeof(char) * intcgm_cgm.len );
+
+       memcpy ( &intcgm_cgm.buff.dados[old_len], &buff[count], len );
+       count += len;
+
+       if ( len & 1 )
+        {
+         count++;
+       
+         intcgm_cgm.bl += 1;
+        }
+      }
+    }
+
+   if ( cgmb_exec_comand ( c, id ) ) return 1;
+   totbc += count;
+   /*count=0;*/
+  }
+
+ return 0;
+}
+
+int cgmb_fntlst ( void )
+{
+ char *fl = NULL;
+
+ if ( intcgm_text_att.font_list==NULL ) intcgm_text_att.font_list = cgm_NewList();
+
+ while ( intcgm_cgm.bc < intcgm_cgm.len )
+  {
+   if ( cgmb_s ( &fl ) ) return 1;
+
+   cgm_AppendList ( intcgm_text_att.font_list, fl );
+  }
+
+ return 0;
+}
+
+int cgmb_chslst ( void )
+{
+ short mode;
+ char *s = NULL;
+
+ while ( intcgm_cgm.bc < intcgm_cgm.len )
+   {
+    if ( cgmb_e ( &mode ) ) return 1;
+    if ( cgmb_s ( &s ) ) return 1;
+   }
+
+ return 0;
+}
+
+int cgmb_chcdac ( void )
+{
+ short mode;
+
+ if ( cgmb_e ( &mode ) ) return 1;
+
+ return 0;
+}
+ 
+
+/******************************
+* Picture Descriptor Elements *
+******************************/
+
+int cgmb_sclmde ( void )
+{
+ if ( cgmb_e ( &(intcgm_cgm.scaling_mode.mode) ) ) return 1;
+ if ( intcgm_cgm.real_prec.b_prec==1 )
+  {
+   if ( cgmb_getfl64 ( &(intcgm_cgm.scaling_mode.scale_factor) )  ) return 1;
+  }
+ else
+  {
+   float f;
+   if ( cgmb_getfl32 ( (float *) &f )  ) return 1;
+   if ( f<1e-20 ) f = 1;
+   intcgm_cgm.scaling_mode.scale_factor = f;
+  }
+
+ if ( intcgm_cgm.scaling_mode.mode==ABSTRACT ) intcgm_cgm.scaling_mode.scale_factor=1.;
+
+ intcgm_cgm.drawing_mode = ABSTRACT;
+
+ if (cdcgmsclmdecb) 
+  {
+   int err;
+   err = cdcgmsclmdecb ( intcgm_canvas, intcgm_cgm.scaling_mode.mode, &intcgm_cgm.drawing_mode, &intcgm_cgm.scaling_mode.scale_factor );
+   if ( err==CD_ABORT ) return -1;
+  }
+
+ if ( intcgm_cgm.drawing_mode==ABSTRACT )
+  {
+   intcgm_clip_xmin = cgm_canvas2vdcx ( intcgm_view_xmin );
+   intcgm_clip_xmax = cgm_canvas2vdcx ( intcgm_view_xmax );
+   intcgm_clip_ymin = cgm_canvas2vdcy ( intcgm_view_ymin );
+   intcgm_clip_ymax = cgm_canvas2vdcy ( intcgm_view_ymax );
+  }
+ else
+  {
+   intcgm_clip_xmin = intcgm_vdc_ext.xmin*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_xmax = intcgm_vdc_ext.xmax*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_ymin = intcgm_vdc_ext.ymin*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_ymax = intcgm_vdc_ext.ymax*intcgm_cgm.scaling_mode.scale_factor;
+  }
+
+ return 0;
+}
+
+int cgmb_clslmd ( void )
+{
+ if ( cgmb_e ( &(intcgm_cgm.clrsm) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_lnwdmd ( void )
+{
+ if ( cgmb_e ( &(intcgm_cgm.lnwsm) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_mkszmd ( void )
+{
+ if ( cgmb_e ( &(intcgm_cgm.mkssm) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_edwdmd ( void )
+{
+ if ( cgmb_e ( &(intcgm_cgm.edwsm) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_vdcext ( void )
+{
+ if ( cgmb_p ( &(intcgm_cgm.vdc_ext.first.x), &(intcgm_cgm.vdc_ext.first.y) ) ) return 1;
+ if ( cgmb_p ( &(intcgm_cgm.vdc_ext.second.x), &(intcgm_cgm.vdc_ext.second.y) ) ) return 1;
+
+ if (cdcgmvdcextcb)
+  {
+   int err;
+   err = cdcgmvdcextcb( intcgm_canvas, intcgm_cgm.vdc_type, &(intcgm_cgm.vdc_ext.first.x), &(intcgm_cgm.vdc_ext.first.y),
+                                              &(intcgm_cgm.vdc_ext.second.x), &(intcgm_cgm.vdc_ext.second.y) );
+   if (err==CD_ABORT) return -1;
+  }
+
+ cgm_do_vdcext ( intcgm_cgm.vdc_ext.first, intcgm_cgm.vdc_ext.second );
+
+ return 0;
+}
+
+int cgmb_bckcol ( void )
+{
+ if ( cgmb_rgb ( &(intcgm_cgm.back_color.red), &(intcgm_cgm.back_color.green), &(intcgm_cgm.back_color.blue) ) ) return 1;
+
+ cgm_do_bckcol ( intcgm_cgm.back_color );
+
+ return 0;
+}
+
+/*******************
+* Control Elements *
+*******************/
+
+int cgmb_vdcipr ( void )
+{
+ long prec;
+
+ if ( cgmb_i ( &prec ) ) return 1;
+
+ if ( prec==8 ) intcgm_cgm.vdc_int.b_prec = 0;
+ else if ( prec==16 )  intcgm_cgm.vdc_int.b_prec = 1; 
+ else if ( prec==24 )  intcgm_cgm.vdc_int.b_prec = 2; 
+ else if ( prec==32 )  intcgm_cgm.vdc_int.b_prec = 3; 
+
+ return 0;
+}
+
+int cgmb_vdcrpr ( void )
+{
+ short i1;
+ long mode, i2, i3;
+
+ if ( cgmb_e ( &i1 ) ) return 1;
+ if ( cgmb_i ( &i2 ) ) return 1;
+ if ( cgmb_i ( &i3 ) ) return 1 ;
+
+ if ( i1 == 0 && i2 == 9 && i3 == 23 ) mode = 0;
+ else if ( i1 == 0 && i2 == 12 && i3 == 52 ) mode = 1;
+ else if ( i1 == 1 && i2 == 16 && i3 == 16 ) mode = 2;
+ else if ( i1 == 1 && i2 == 32 && i3 == 32 ) mode = 3;
+
+ intcgm_cgm.vdc_real.b_prec = mode;
+
+ return 0;
+}
+
+int cgmb_auxcol ( void )
+{
+ if ( cgmb_co ( &(intcgm_cgm.aux_color) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_transp ( void )
+{
+ if ( cgmb_e ( &(intcgm_cgm.transparency) ) ) return 1;
+
+ cgm_do_transp ( intcgm_cgm.transparency );
+
+ return 0;
+}
+
+int cgmb_clprec ( void )
+{
+ if ( cgmb_p   ( &(intcgm_cgm.clip_rect.first.x),  &(intcgm_cgm.clip_rect.first.y) ) ) return 1;
+ if ( cgmb_p   ( &(intcgm_cgm.clip_rect.second.x),  &(intcgm_cgm.clip_rect.second.y) ) ) return 1;
+
+ cgm_do_clprec ( intcgm_cgm.clip_rect.first, intcgm_cgm.clip_rect.second );
+
+ return 0;
+}
+
+int cgmb_clpind ( void )
+{
+ if ( cgmb_e   ( &(intcgm_cgm.clip_ind) ) ) return 1;
+
+ cgm_do_clpind ( intcgm_cgm.clip_ind );
+
+ return 0;
+}
+
+/*******************************
+* Graphical Primitive Elements *
+*******************************/
+
+static tpoint *_intcgm_point_list ( int *np )
+{
+ *np=0;
+
+ while ( intcgm_cgm.bc < intcgm_cgm.len )
+   {
+    if ( cgmb_p ( &(intcgm_point_list[*np].x), &(intcgm_point_list[*np].y) ) ) return NULL;
+    ++(*np);
+    if ( *np==intcgm_npoints)
+      {
+       intcgm_npoints *= 2;
+       intcgm_point_list = (tpoint *) realloc ( intcgm_point_list, intcgm_npoints*sizeof(tpoint) );
+      }
+   }
+
+ return intcgm_point_list;
+}
+
+int cgmb_polyln ( void )
+{
+ tpoint *pts;
+ int np;
+
+ pts = _intcgm_point_list ( &np );
+ if ( pts==NULL ) return 1;
+
+ cgm_do_polyln ( np, pts );
+
+ return 0;
+}
+
+int cgmb_djtply ( void )
+{
+ tpoint *pts;
+ int np;
+
+ pts = _intcgm_point_list ( &np );
+ if ( pts==NULL ) return 1;
+
+ cgm_do_djtply ( np, pts );
+
+ return 0;
+}
+
+int cgmb_polymk ( void )
+{
+ tpoint *pts;
+ int np;
+
+ pts = _intcgm_point_list ( &np );
+ if ( pts==NULL ) return 1;
+
+ cgm_do_polymk ( np, pts );
+
+ return 0;
+}
+
+int cgmb_text ( void )
+{
+ tpoint pos;
+ char *s = NULL;
+ short t;
+
+ if ( cgmb_p ( &pos.x, &pos.y ) ) return 1;
+ if ( cgmb_e ( &t ) ) return 1;
+ if ( cgmb_s ( &s ) ) return 1;
+
+ cgm_do_text ( NORM_TEXT, s, pos );
+
+ free ( s );
+
+ return 0;
+}
+
+int cgmb_rsttxt ( void )
+{
+ double height, width;
+ tpoint pos;
+ char *s = NULL;
+ short t;
+
+ if ( cgmb_vdc ( &width ) ) return 1;
+ if ( cgmb_vdc ( &height ) ) return 1;
+ if ( cgmb_p ( &pos.x, &pos.y ) ) return 1;
+ if ( cgmb_e ( &t ) ) return 1;
+ if ( cgmb_s ( &s ) ) return 1;
+
+ intcgm_text_att.height = height;
+
+ cgm_do_text ( RESTRICTED_TEXT, s, pos );
+
+ if ( s!= NULL ) free ( s );
+
+ return 0;
+}
+
+int cgmb_apdtxt ( void )
+{
+ char *s = NULL;
+ short t;
+
+ if ( cgmb_e ( &t ) ) return 1;
+ if ( cgmb_s ( &s ) ) return 1;
+
+ if ( s==NULL ) free ( s );
+
+ return 0;
+}
+
+int cgmb_polygn ( void )
+{
+ tpoint *pts;
+ int np;
+ static int porra=0;
+
+ porra++;
+
+ pts = _intcgm_point_list ( &np );
+ if ( pts==NULL ) return 1;
+
+ cgm_do_polygn ( np, pts );
+
+ return 0;
+}
+
+static int _intcgm_vertex_list ( tpoint **pts, short **flags, int *np )
+{
+ int intcgm_block=500;
+
+ *np=0;
+ *pts = (tpoint *) malloc ( intcgm_block*sizeof(tpoint) );
+ *flags = (short *) malloc ( intcgm_block*sizeof(short) );
+
+ while ( intcgm_cgm.bc < intcgm_cgm.len )
+   {
+    if ( cgmb_p ( &((*pts)[*np].x), &((*pts)[*np].y) ) ) return 1;
+    if ( cgmb_e ( &((*flags)[*np]) ) ) return 1;
+
+    ++(*np);
+    if ( *np==intcgm_block)
+      {
+       intcgm_block *= 2;
+       *pts = (tpoint *) realloc ( *pts, intcgm_block*sizeof(tpoint) );
+       *flags = (short *) realloc ( *flags, intcgm_block*sizeof(short) );
+      }
+   }
+
+ return 0;
+}
+
+int cgmb_plgset ( void )
+{
+ tpoint *pts;
+ short *flags;
+ int np;
+
+ if ( _intcgm_vertex_list (  &pts, &flags, &np ) ) return 1;
+
+ cgm_do_plgset( NO, np, pts, flags );
+
+ free ( pts );
+ free ( flags );
+
+ return 0;
+}
+
+int cgmb_cellar ( void )
+{
+ register int i, j, k;
+ long prec;
+ long sx, sy;
+ short mode;
+ int b;
+ unsigned char dummy;
+ tpoint corner1, corner2, corner3;
+ tcolor *cell;
+
+ if ( cgmb_p ( &(corner1.x), &(corner1.y) ) ) return 1;
+ if ( cgmb_p ( &(corner2.x), &(corner2.y) ) ) return 1;
+ if ( cgmb_p ( &(corner3.x), &(corner3.y) ) ) return 1;
+
+ if ( cgmb_i ( &sx ) ) return 1;
+ if ( cgmb_i ( &sy ) ) return 1;
+
+ if ( cgmb_i ( &prec ) ) return 1;
+
+ if ( cgmb_e ( &mode ) ) return 1;
+
+ cell = (tcolor *) malloc ( sx*sy*sizeof(tcolor) );
+
+ if ( mode )
+  for ( k=0; k<sy; k++ )
+   {
+    b=intcgm_cgm.bc;
+	  intcgm_cgm.pc=0;
+    for ( i=0; i<sx; i++ )
+     {
+      if ( cgmb_getpixel ( &(cell[k*sx+i]), prec ) ) return 1;
+     }
+    if ( k<(sy-1) && (intcgm_cgm.bc-b)%2 ) cgmb_getc ( &dummy );
+    cgm_getfilepos();
+   }
+ else
+  for ( k=0; k<sy; k++ )
+   {
+    b=intcgm_cgm.bc;
+	  intcgm_cgm.pc=0;
+    for ( i=0; i<sx; )
+     {
+      long l;
+      tcolor cor;
+      if ( cgmb_i ( &l ) ) return 1;
+      if ( cgmb_getpixel ( &cor, prec ) ) return 1;
+      for ( j=0; j<l; j++ )
+       {  
+        cell[k*sx+i] = cor;
+        i++;
+       }
+     }
+    if ( k<(sy-1) && (intcgm_cgm.bc-b)%2 ) cgmb_getc ( &dummy );
+    cgm_getfilepos();
+   }
+
+ if ( intcgm_cgm.clrsm == 0 ) /* indexed */
+  {
+   for ( i=0; i<sx*sy; i++ )
+    {
+     int ind = cell[i].ind;
+     cell[i].rgb.red = intcgm_color_table[ind].red;
+     cell[i].rgb.green = intcgm_color_table[ind].green;
+     cell[i].rgb.blue = intcgm_color_table[ind].blue;
+	 }
+  }
+
+ cgm_do_cellar ( corner1, corner2, corner3, sx, sy, prec, cell );
+
+ free ( cell );
+
+ return 0;
+}
+
+static long sample_type, n_samples;
+
+static int BuildString ( char *sin, char **sout, int *slen, int *intcgm_block )
+{
+ *slen = strlen ( sin ) + strlen(*sout) + 1 + 1; /* + espaco em branco no final +\0 */
+ if (*slen > *intcgm_block)
+  {
+   *intcgm_block *= 2;
+   *sout = (char *) realloc(*sout,sizeof(char)*(*intcgm_block));
+   if ( *sout==NULL ) return 1;
+  }
+
+ strcat(*sout,sin);
+ strcat(*sout," ");
+
+ return 0;
+}
+
+int intcgm_generalized_drawing_primitive_4 ( void )
+{
+ long j, i;
+ tpoint pt[4];
+ unsigned char c;
+ double r;
+ char *s=NULL, tmp[80];
+ int intcgm_block = 500, slen = 0;
+ int id = -4;
+
+ s = (char *) malloc ( intcgm_block*sizeof(char) );
+
+ strcpy ( s, "" );
+
+ for ( j=0; j<4; j++ )
+  {
+   if ( cgmb_p ( &(pt[j].x), &(pt[j].y) ) ) return 1;
+  }
+
+ if ( cgmb_getc(&c) ) return 1;
+ if ( cgmb_getc(&c) ) return 1;
+
+ for ( j=0; j<6; j++ )
+   {
+    if ( cgmb_r(&r) ) return 1;
+    sprintf(tmp,"%g",r);
+	if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+   }
+
+ if ( cgmb_i(&i) ) return 1;
+ sprintf(tmp,"%ld",i);
+ if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+
+ if ( cgmb_i(&sample_type) ) return 1;
+ sprintf(tmp,"%ld",sample_type);
+ if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+
+ if ( cgmb_i(&n_samples) ) return 1;
+ sprintf(tmp,"%ld",n_samples);
+ if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+
+ for ( j=0; j<2; j++ )
+   {
+    if ( cgmb_r(&r) ) return 1;
+    sprintf(tmp,"%g",r);
+    if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+   }
+
+ for ( j=0; j<4; j++ )
+   {
+    if ( cgmb_i(&i) ) return 1;
+    sprintf(tmp,"%ld",i);
+    if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+   }
+
+ cgm_do_gdp ( id, pt, s );
+
+ free(s);
+
+ return 0;
+}
+
+typedef int (*_getdata) (void *);
+
+int intcgm_generalized_drawing_primitive_5 ( void )
+{
+ int  (*getdata) (void *);
+ void  *data;
+ char  format[10];
+ int   i;
+ char  *s, tmp[80];
+ int   intcgm_block = 500, slen = 0;
+ long  id=-5;
+
+ s = (char *) malloc ( sizeof(char)*intcgm_block );
+
+ strcpy ( s, "" );
+
+ switch ( sample_type )
+   {
+    case 0:
+      getdata = (_getdata) cgmb_geti16;
+      data = (short *) malloc ( sizeof(short) );
+	  if ( data==NULL ) return 1;
+      strcpy ( format, "%d\0" );
+      break;
+    case 1:
+      getdata = (_getdata) cgmb_geti32;
+      data = (long *) malloc ( sizeof(long) );
+	  if ( data==NULL ) return 1;
+      strcpy ( format, "%d\0" );
+      break;
+    case 2:
+      getdata = (_getdata) cgmb_getfl32;
+      data = (float *) malloc ( sizeof(float) );
+	  if ( data==NULL ) return 1;
+      strcpy ( format, "%g\0" );
+      break;
+    case 3:
+      getdata = (_getdata) cgmb_geti8;
+      data = (signed char *) malloc ( sizeof(signed char) );
+	  if ( data==NULL ) return 1;
+      strcpy ( format, "%d\0" );
+      break;
+    case 4:
+      getdata = (_getdata) cgmb_geti16;
+      data = (short *) malloc ( sizeof(short) );
+	  if ( data==NULL ) return 1;
+      strcpy ( format, "%d\0" );
+      break;
+    case 5:
+      getdata = (_getdata) cgmb_geti8;
+      data = (signed char *) malloc ( sizeof(signed char) );
+	  if ( data==NULL ) return 1;
+      strcpy ( format, "%d\0" );
+      break;
+   }
+
+ for ( i=0; i<n_samples; i++ )
+   {
+
+    getdata(data);
+
+    if (sample_type==0)
+      sprintf(tmp,format,*(short *)data);
+    else if (sample_type==1)
+      sprintf(tmp,format,*(long *)data);
+    else if (sample_type==2)
+      sprintf(tmp,format,*(float *)data);
+    else if (sample_type==3)
+      sprintf(tmp,format,*(signed char *)data);
+    else if (sample_type==4)
+      sprintf(tmp,format,*(short *)data);
+    else if (sample_type==5)
+      sprintf(tmp,format,*(signed char *)data);
+
+    if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+
+    if (sample_type==4 || sample_type==5)
+      {
+       unsigned long ci;
+       char endstr='\0';
+
+       if ( cgmb_ci  ( &ci ) ) return 1;
+       sprintf(tmp,"%ld%c",ci,endstr);
+       if ( BuildString ( tmp, &s, &slen, &intcgm_block ) ) return 1;
+      }
+  }
+
+ if ( intcgm_cgm.bc < intcgm_cgm.len )
+  {
+   int i;
+   unsigned char c;
+
+   for ( i=0; i<intcgm_cgm.len-intcgm_cgm.bc; i++ )
+    {
+     if ( cgmb_getc(&c) ) return 1;
+     if ( cgmb_getc(&c) ) return 1;
+    }
+  }
+
+ cgm_do_gdp ( id, NULL, s );
+
+ free(s);
+
+ return 0;
+}
+
+int cgmb_gdp ( void )
+{
+ long id, n, i;
+ double x, y;
+ char *s = NULL;
+
+ cgmb_i ( &id );
+
+ if ( id==-4 ) 
+  {
+   if ( intcgm_generalized_drawing_primitive_4 ( ) ) return 1;
+  }
+ else if ( id==-5 ) 
+  {
+   if ( intcgm_generalized_drawing_primitive_5 ( ) ) return 1;
+  }
+ else
+  {
+   if ( cgmb_i ( &n ) ) return 1;
+   for ( i=0; i<n; i++ )
+    {
+	   if ( cgmb_p ( &x, &y ) ) return 1;
+	  }
+   if ( cgmb_s ( &s ) ) return 1;
+  }
+
+ return 0;
+}
+
+int cgmb_rect ( void )
+{
+ tpoint point1;
+ tpoint point2;
+
+ if ( cgmb_p ( &(point1.x), &(point1.y) ) ) return 1;
+ if ( cgmb_p ( &(point2.x), &(point2.y) ) ) return 1;
+
+ cgm_do_rect ( point1, point2 );
+
+ return 0;
+}
+
+int cgmb_circle ( void )
+{
+ tpoint center;
+ double radius;
+
+ if ( cgmb_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &radius ) ) return 1;
+
+ cgm_do_circle ( center, radius );
+
+ return 0;
+}
+
+int cgmb_circ3p ( void )
+{
+ tpoint starting;
+ tpoint intermediate;
+ tpoint ending;
+
+ if ( cgmb_p ( &(starting.x), &(starting.y) ) ) return 1;
+ if ( cgmb_p ( &(intermediate.x), &(intermediate.y) ) ) return 1;
+ if ( cgmb_p ( &(ending.x), &(ending.y) ) ) return 1;
+
+ cgm_do_circ3p ( starting, intermediate, ending );
+
+ return 0;
+}
+
+int cgmb_cir3pc ( void )
+{
+ tpoint starting;
+ tpoint intermediate;
+ tpoint ending;
+ short close_type;
+
+ if ( cgmb_p ( &(starting.x), &(starting.y) ) ) return 1;
+ if ( cgmb_p ( &(intermediate.x), &(intermediate.y) ) ) return 1;
+ if ( cgmb_p ( &(ending.x), &(ending.y) ) ) return 1;
+
+ if ( cgmb_e ( &close_type ) ) return 1;
+
+ cgm_do_circ3pc ( starting, intermediate, ending, close_type );
+
+ return 0;
+}
+
+int cgmb_circnt ( void )
+{
+ tpoint center;
+ tpoint start;
+ tpoint end;
+ double  radius;
+
+ if ( cgmb_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(start.x) ) ) return 1;
+ if ( cgmb_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(end.x) ) ) return 1;
+ if ( cgmb_vdc ( &(end.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &radius ) ) return 1;
+
+ cgm_do_circcnt ( center, start, end, radius );
+
+ return 0;
+}
+
+int cgmb_ccntcl ( void )
+{
+ tpoint center;
+ tpoint start;
+ tpoint end;
+ double radius;
+ short close_type;
+
+ if ( cgmb_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(start.x) ) ) return 1;
+ if ( cgmb_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(end.x) ) ) return 1;
+ if ( cgmb_vdc ( &(end.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &radius ) ) return 1;
+
+ if ( cgmb_e ( &close_type ) ) return 1;
+
+ cgm_do_ccntcl ( center, start, end, radius, close_type );
+
+ return 0;
+}
+
+int cgmb_ellips ( void )
+{
+ tpoint center;
+ tpoint first_CDP;
+ tpoint second_CDP;
+
+ if ( cgmb_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmb_p ( &(first_CDP.x), &(first_CDP.y) ) ) return 1;
+ if ( cgmb_p ( &(second_CDP.x), &(second_CDP.y) ) ) return 1;
+
+ cgm_do_ellips ( center, first_CDP, second_CDP );
+
+ return 0;
+}
+
+int cgmb_ellarc ( void )
+{
+ tpoint center;
+ tpoint first_CDP;
+ tpoint second_CDP;
+ tpoint start, end;
+
+ if ( cgmb_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmb_p ( &(first_CDP.x), &(first_CDP.y) ) ) return 1;
+ if ( cgmb_p ( &(second_CDP.x), &(second_CDP.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(start.x) ) ) return 1;
+ if ( cgmb_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(end.x) ) ) return 1;
+ if ( cgmb_vdc ( &(end.y) ) ) return 1;
+
+ cgm_do_ellarc ( center, first_CDP, second_CDP, start, end );
+
+ return 0;
+}
+
+int cgmb_ellacl ( void )
+{
+
+ tpoint center;
+ tpoint first_CDP;
+ tpoint second_CDP;
+ tpoint start, end;
+ short close_type;
+
+ if ( cgmb_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmb_p ( &(first_CDP.x), &(first_CDP.y) ) ) return 1;
+ if ( cgmb_p ( &(second_CDP.x), &(second_CDP.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(start.x) ) ) return 1;
+ if ( cgmb_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmb_vdc ( &(end.x) ) ) return 1;
+ if ( cgmb_vdc ( &(end.y) ) ) return 1;
+
+ if ( cgmb_e ( &close_type ) ) return 1;
+
+ cgm_do_ellacl ( center, first_CDP, second_CDP, start, end, close_type );
+
+ return 0;
+}
+
+/*********************
+* Attribute Elements *
+*********************/
+
+int cgmb_lnbdin( void )
+{
+ if ( cgmb_ix ( &(intcgm_line_att.index) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_lntype ( void )
+{
+ if ( cgmb_ix ( &(intcgm_line_att.type) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_lnwidt ( void )
+{
+ if ( intcgm_cgm.lnwsm==0 )
+  {
+   if ( cgmb_vdc ( &(intcgm_line_att.width) ) ) return 1;
+  }
+ else
+  {
+   if ( cgmb_r ( &(intcgm_line_att.width) ) ) return 1;
+  }
+
+ return 0;
+}
+
+int cgmb_lncolr( void )
+{
+ if ( cgmb_co ( &(intcgm_line_att.color) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_mkbdin( void )
+{
+ if ( cgmb_ix ( &(intcgm_marker_att.index) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_mktype( void )
+{
+ if ( cgmb_ix ( &(intcgm_marker_att.type) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_mksize( void )
+{
+ if ( intcgm_cgm.mkssm == 0 )
+  {
+   if ( cgmb_vdc ( &(intcgm_marker_att.size) ) ) return 1;
+  }
+ else
+  {
+   if ( cgmb_r ( &(intcgm_marker_att.size) ) ) return 1;
+  }
+
+ return 0;
+}
+
+int cgmb_mkcolr( void )
+{
+ if ( cgmb_co ( &(intcgm_marker_att.color) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_txbdin( void )
+{
+ if ( cgmb_ix ( &(intcgm_text_att.index) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_txftin ( void )
+{
+ char *font;
+ char *font_array[] = {"SYSTEM", "COURIER", "TIMES", "HELVETICA", NULL};
+ char *style_array[] = {"BOLDITALIC", "ITALIC", "BOLD", "PLAIN", NULL};
+ int cdstyle[] = {CD_BOLD_ITALIC, CD_ITALIC, CD_BOLD, CD_PLAIN};
+ int i;
+
+ if ( cgmb_ix ( &(intcgm_text_att.font_index) ) ) return 1;
+
+ font = (char *) cgm_GetList ( intcgm_text_att.font_list, intcgm_text_att.font_index );
+
+ if ( font==NULL ) font = (char*)strdup ( "SYSTEM" );
+
+ intcgm_text_att.font = 0;
+ for ( i=0; font_array[i]!=NULL; i++ )
+  {
+   if ( strstr( font, font_array[i] ) )
+    {
+     intcgm_text_att.font = i;
+     break;
+    }
+  }
+
+ intcgm_text_att.style = 0;
+ for ( i=0; style_array[i]!=NULL; i++ )
+  {
+   if ( strstr( font, style_array[i] ) )
+    {
+     intcgm_text_att.style = cdstyle[i];
+     break;
+    }
+  }
+
+ cgm_setfont ( intcgm_text_att.font, intcgm_text_att.style, intcgm_text_att.height );
+
+ return 0;
+}
+
+int cgmb_txtprc( void )
+{
+ if ( cgmb_e ( &(intcgm_text_att.prec) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_chrexp ( void )
+{
+ if ( cgmb_r ( &(intcgm_text_att.exp_fact) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_chrspc ( void )
+{
+ if ( cgmb_r ( &(intcgm_text_att.char_spacing) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_txtclr( void )
+{
+ if ( cgmb_co ( &(intcgm_text_att.color) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_chrhgt ( void )
+{
+ if ( cgmb_vdc ( &(intcgm_text_att.height) ) ) return 1;
+
+ cgm_do_text_height ( intcgm_text_att.height );
+
+ return 0;
+}
+
+int cgmb_chrori ( void )
+{
+ if ( cgmb_vdc ( &(intcgm_text_att.char_up.x) ) ) return 1;
+ if ( cgmb_vdc ( &(intcgm_text_att.char_up.y) ) ) return 1;
+ if ( cgmb_vdc ( &(intcgm_text_att.char_base.x) ) ) return 1;
+ if ( cgmb_vdc ( &(intcgm_text_att.char_base.y) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_txtpat ( void )
+{
+ if ( cgmb_e ( &(intcgm_text_att.path) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_txtali ( void )
+{
+ if ( cgmb_e ( &(intcgm_text_att.alignment.hor) ) ) return 1;
+ if ( cgmb_e ( &(intcgm_text_att.alignment.ver) ) ) return 1;
+
+ if ( cgmb_r ( &(intcgm_text_att.alignment.cont_hor) ) ) return 1;
+ if ( cgmb_r ( &(intcgm_text_att.alignment.cont_ver) ) ) return 1;
+
+ cgm_do_txtalign ( intcgm_text_att.alignment.hor, intcgm_text_att.alignment.ver );
+
+ return 0;
+}
+
+int cgmb_chseti( void )
+{
+ long set;
+
+ if ( cgmb_ix ( &set ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_achsti( void )
+{
+ long set;
+
+ if ( cgmb_i ( &set ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_fillin( void )
+{
+ if ( cgmb_ix ( &(intcgm_fill_att.index) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_intsty( void )
+{
+ if ( cgmb_e ( &(intcgm_fill_att.int_style) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_fillco( void )
+{
+ if ( cgmb_co ( &(intcgm_fill_att.color) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_hatind( void )
+{
+ if ( cgmb_ix ( &(intcgm_fill_att.hatch_index) ) ) return 1;
+ if ( intcgm_fill_att.hatch_index==3 ) intcgm_fill_att.hatch_index = 4;
+ else if ( intcgm_fill_att.hatch_index==4 ) intcgm_fill_att.hatch_index = 3;
+
+ return 0;
+}
+
+int cgmb_patind( void )
+{
+ if ( cgmb_ix ( &(intcgm_fill_att.pat_index) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_edgind( void )
+{
+ if ( cgmb_ix ( &(intcgm_edge_att.index) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_edgtyp( void )
+{
+ if ( cgmb_ix ( &(intcgm_edge_att.type) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_edgwid ( void )
+{
+ if ( intcgm_cgm.edwsm==0 )
+  {
+   if ( cgmb_vdc ( &(intcgm_edge_att.width) ) ) return 1;
+  }
+ else
+  {
+   if ( cgmb_r ( &(intcgm_edge_att.width) ) ) return 1;
+  }
+
+ return 0;
+}
+
+int cgmb_edgcol ( void )
+{
+ if ( cgmb_co ( &(intcgm_edge_att.color) ) ) return 1;
+
+ return 0;
+}
+ 
+
+int cgmb_edgvis ( void )
+{
+ if ( cgmb_e ( &(intcgm_edge_att.visibility) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_fillrf ( void )
+{
+ if ( cgmb_p ( &(intcgm_fill_att.ref_pt.x),  &(intcgm_fill_att.ref_pt.y) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_pattab ( void )
+{
+ long localp;
+ int i;
+ pat_table *pat;
+
+ pat = (pat_table *) malloc ( sizeof(pat_table) );
+
+ if ( intcgm_fill_att.pat_list==NULL ) intcgm_fill_att.pat_list = cgm_NewList();
+
+ if ( cgmb_i ( &(pat->index) ) ) return 1;
+
+ if ( cgmb_i ( &(pat->nx) ) ) return 1;
+ if ( cgmb_i ( &(pat->ny) ) ) return 1;
+
+ if ( cgmb_i ( &(localp) ) ) return 1;
+
+ pat->pattern = (tcolor *) malloc ( pat->nx*pat->ny*sizeof(tcolor) );
+
+ for ( i=0; i<(pat->nx*pat->ny); i++ )
+  {
+   if ( cgmb_getpixel ( &(pat->pattern[i]), localp ) ) return 1;
+  }
+
+ cgm_AppendList ( intcgm_fill_att.pat_list, pat );
+
+ return 0;
+}
+
+int cgmb_patsiz ( void )
+{
+ if ( cgmb_vdc ( &(intcgm_fill_att.pat_size.height.x) ) ) return 1;
+ if ( cgmb_vdc ( &(intcgm_fill_att.pat_size.height.y) ) ) return 1;
+ if ( cgmb_vdc ( &(intcgm_fill_att.pat_size.width.x) ) ) return 1;
+ if ( cgmb_vdc ( &(intcgm_fill_att.pat_size.width.y) ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_coltab ( void )
+{
+ unsigned long starting_index, i;
+ int p[] = {8, 16, 24, 32};
+ int n = (intcgm_cgm.len-intcgm_cgm.cix_prec)/(3*(p[intcgm_cgm.cd_prec]/8));
+
+ if ( cgmb_ci ( &(starting_index) ) ) return 1;
+
+ for ( i=starting_index; i<starting_index+n; i++ )
+  {
+   if ( cgmb_rgb ( &(intcgm_color_table[i].red), &(intcgm_color_table[i].green), &(intcgm_color_table[i].blue) ) ) return 1;
+  }
+
+ if ( intcgm_cgm.bc==(intcgm_cgm.len-1) ) intcgm_cgm.bc++;
+
+ return 0;
+}
+
+int cgmb_asf ( void )
+{
+ tasf *pair;
+
+ if ( intcgm_asf_list==NULL ) intcgm_asf_list = cgm_NewList();
+
+ while( intcgm_cgm.bc < intcgm_cgm.len )
+  {
+   pair = (tasf *) malloc ( sizeof (tasf) );
+
+   if ( cgmb_e ( &(pair->type) ) ) return 1;
+   if ( cgmb_e ( &(pair->value) ) ) return 1;
+
+   cgm_AppendList ( intcgm_asf_list, pair );
+  }
+
+ return 0;
+}
+
+/*****************
+* Escape Element *
+*****************/
+
+/********************
+* External elements *
+********************/
+
+int cgmb_escape ( void )   /* escape */
+{
+#if 1
+
+ {
+  int i;
+  unsigned char c;
+  for ( i=0; i<intcgm_cgm.len; i++ ) cgmb_getc(&c);
+ }
+
+#else
+
+ {
+ long identifier;
+ char *data_rec;
+
+ if ( cgmb_i ( &(identifier) ) ) return 1;
+
+ if ( cgmb_s ( &data_rec ) ) return 1;
+
+ free(data_rec);
+ }
+
+#endif
+                  
+ return 0;
+}
+
+int cgmb_messag ( void )
+{
+ char *text;
+ short flag;
+
+ if ( cgmb_e ( &flag ) ) return 1;
+
+ if ( cgmb_s ( &text ) ) return 1;
+
+ free(text);
+
+ return 0;
+}
+
+int cgmb_appdta ( void )
+{
+ long identifier;
+ char *data_rec;
+
+ if ( cgmb_i ( &identifier ) ) return 1;
+
+ if ( cgmb_s ( &data_rec ) ) return 1;
+
+ free(data_rec);
+
+ return 0;
+}
diff --git a/src/intcgm/bparse.h b/src/intcgm/bparse.h
new file mode 100644
index 0000000..1b86fee
--- /dev/null
+++ b/src/intcgm/bparse.h
@@ -0,0 +1,117 @@
+#ifndef _BPARSE_H_
+#define _BPARSE_H_
+
+typedef int(*_cdcgmsizecb)(cdCanvas* canvas, int w, int h, double w_mm, double h_mm);
+typedef int(*_cdcgmbegmtfcb)(cdCanvas* canvas, int *xmin, int *ymin, int *xmax, int *ymax);
+typedef int(*_cdcgmcountercb)(cdCanvas* canvas, double size);
+typedef int(*_cdcgmsclmdecb)(cdCanvas* canvas, short scl_mde, short *drw_mode, double *factor);
+typedef int(*_cdcgmvdcextcb)(cdCanvas* canvas, short type, double *xmn, double *ymn, double *xmx, double *ymx);
+typedef int(*_cdcgmbegpictcb)(cdCanvas* canvas , char *pict );
+typedef int(*_cdcgmbegpictbcb)(cdCanvas* canvas, double scale_x, double scale_y, 
+                               double vdc_x2pix, double vdc_y2pix,
+                               double vdc_x2mm, double vdc_y2mm, int drw_mode, 
+                               double xmin, double ymin, double xmax, double ymax);
+
+extern _cdcgmsizecb cdcgmsizecb;
+extern _cdcgmbegmtfcb cdcgmbegmtfcb;
+extern _cdcgmcountercb cdcgmcountercb;
+extern _cdcgmsclmdecb cdcgmsclmdecb;
+extern _cdcgmvdcextcb cdcgmvdcextcb;
+extern _cdcgmbegpictcb cdcgmbegpictcb;
+extern _cdcgmbegpictbcb cdcgmbegpictbcb;
+
+int cgmb_noop ( void );
+int cgmb_begmtf ( void );
+int cgmb_endmtf ( void );
+int cgmb_begpic ( void );
+int cgmb_begpib ( void );
+int cgmb_endpic ( void );
+int cgmb_mtfver ( void );
+int cgmb_mtfdsc ( void );
+int cgmb_vdctyp ( void );
+int cgmb_intpre ( void );
+int cgmb_realpr ( void );
+int cgmb_indpre ( void );
+int cgmb_colpre ( void );
+int cgmb_colipr ( void );
+int cgmb_maxcoi ( void );
+int cgmb_covaex ( void );
+int cgmb_mtfell ( void );
+int cgmb_bmtfdf ( void );
+int cgmb_fntlst ( void );
+int cgmb_chslst ( void );
+int cgmb_chcdac ( void );
+int cgmb_sclmde ( void );
+int cgmb_clslmd ( void );
+int cgmb_lnwdmd ( void );
+int cgmb_mkszmd ( void );
+int cgmb_edwdmd ( void );
+int cgmb_vdcext ( void );
+int cgmb_bckcol ( void );
+int cgmb_vdcipr ( void );
+int cgmb_vdcrpr ( void );
+int cgmb_auxcol ( void );
+int cgmb_transp ( void );
+int cgmb_clprec ( void );
+int cgmb_clpind ( void );
+int cgmb_polyln ( void );
+int cgmb_djtply ( void );
+int cgmb_polymk ( void );
+int cgmb_text ( void );
+int cgmb_rsttxt ( void );
+int cgmb_apdtxt ( void );
+int cgmb_polygn ( void );
+int cgmb_plgset ( void );
+int cgmb_cellar ( void );
+int cgm_generalized_drawing_primitive_4 ( void );
+int cgm_generalized_drawing_primitive_5 ( void );
+int cgmb_gdp ( void );
+int cgmb_rect ( void );
+int cgmb_circle ( void );
+int cgmb_circ3p ( void );
+int cgmb_cir3pc ( void );
+int cgmb_circnt ( void );
+int cgmb_ccntcl ( void );
+int cgmb_ellips ( void );
+int cgmb_ellarc ( void );
+int cgmb_ellacl ( void );
+int cgmb_lnbdin ( void );
+int cgmb_lntype ( void );
+int cgmb_lnwidt ( void );
+int cgmb_lncolr ( void );
+int cgmb_mkbdin ( void );
+int cgmb_mktype ( void );
+int cgmb_mksize ( void );
+int cgmb_mkcolr ( void );
+int cgmb_txbdin ( void );
+int cgmb_txftin ( void );
+int cgmb_txtprc ( void );
+int cgmb_chrexp ( void );
+int cgmb_chrspc ( void );
+int cgmb_txtclr ( void );
+int cgmb_chrhgt ( void );
+int cgmb_chrori ( void );
+int cgmb_txtpat ( void );
+int cgmb_txtali ( void );
+int cgmb_chseti ( void );
+int cgmb_achsti ( void );
+int cgmb_fillin ( void );
+int cgmb_intsty ( void );
+int cgmb_fillco ( void );
+int cgmb_hatind ( void );
+int cgmb_patind ( void );
+int cgmb_edgind ( void );
+int cgmb_edgtyp ( void );
+int cgmb_edgwid ( void );
+int cgmb_edgcol ( void );
+int cgmb_edgvis ( void );
+int cgmb_fillrf ( void );
+int cgmb_pattab ( void );
+int cgmb_messag ( void );
+int cgmb_appdta ( void );
+int cgmb_patsiz ( void );
+int cgmb_coltab ( void );
+int cgmb_asf ( void );
+int cgmb_escape ( void );
+
+#endif
diff --git a/src/intcgm/circle.c b/src/intcgm/circle.c
new file mode 100644
index 0000000..4f54fed
--- /dev/null
+++ b/src/intcgm/circle.c
@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <math.h>
+
+#include <cd.h>
+
+#include "list.h"
+#include "types.h"
+#include "intcgm.h"
+#include "intcgm6.h"
+
+#include "circle.h"
+
+#define DIM 360
+
+#ifndef PI
+#define PI 3.14159265358979323846
+#endif
+
+#define PI180 PI/180.
+#define TWOPI 2*PI
+#define VARCS TWOPI/32.
+
+int cgm_poly_circle ( double xc, double yc, double radius, double angi, double angf, int fechado )
+{
+ double coseno, seno;
+ double xs, ys;
+ 
+ coseno = cos (VARCS);
+ seno   = sin (VARCS);
+
+ xs = radius * cos(angi);
+ ys = radius * sin(angi);
+
+ cdCanvasBegin(intcgm_canvas,  cgm_setintstyle(intcgm_fill_att.int_style) );
+
+ if ( fechado==CLOSED_PIE ) cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(xc), cgm_vdcy2canvas(yc) );
+
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(xc+xs), cgm_vdcy2canvas(yc+ys) );
+
+ while ( (angi+VARCS) < angf )
+  {
+   double xe = xs;
+   xs = xs * coseno - ys * seno;
+   ys = ys * coseno + xe * seno;
+   cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(xc+xs), cgm_vdcy2canvas(yc+ys) );
+   angi += VARCS;
+  }
+
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(xc+radius*cos(angf)), cgm_vdcy2canvas(yc+radius*sin(angf)) );
+
+ cdCanvasEnd(intcgm_canvas);
+
+ return 0;
+}
+
+int cgm_line_circle ( double xc, double yc, double radius, double angi, double angf, int fechado )
+{
+ double coseno, seno;
+ double xant, yant, firstx, firsty;
+ double xs, ys;
+
+ /* GERA O DESENHO DO CIRCULO/ARCO */
+
+ coseno = cos (VARCS);
+ seno   = sin (VARCS);
+
+ xs = radius * cos(angi);
+ ys = radius * sin(angi);
+
+ if ( fechado==CLOSED_PIE )
+  cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(xc), cgm_vdcy2canvas(yc), cgm_vdcx2canvas(xc+xs), cgm_vdcy2canvas(yc+ys) );
+
+ xant = firstx = xc+xs;
+ yant = firsty = yc+ys;
+
+ while ( (angi+VARCS) < angf )
+  {
+   double xe = xs;
+   xs = xs * coseno - ys * seno;
+   ys = ys * coseno + xe * seno;
+   cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(xant), cgm_vdcy2canvas(yant), cgm_vdcx2canvas(xc+xs), cgm_vdcy2canvas(yc+ys) );
+   xant = xc+xs;
+   yant = yc+ys;
+   angi += VARCS;
+  }
+
+ cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(xant), cgm_vdcy2canvas(yant),
+          cgm_vdcx2canvas(xc+radius*cos(angf)), cgm_vdcy2canvas(yc+radius*sin(angf)) );
+
+ xant = xc+radius*cos(angf);
+ yant = yc+radius*sin(angf);
+
+ if ( fechado==CLOSED_PIE )
+  cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(xant), cgm_vdcy2canvas(yant), cgm_vdcx2canvas(xc), cgm_vdcy2canvas(yc) );
+ else if ( fechado==CLOSED_CHORD )
+  cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(xant), cgm_vdcy2canvas(yant), cgm_vdcx2canvas(firstx), cgm_vdcy2canvas(firsty) );
+
+ return 0;
+}
+
diff --git a/src/intcgm/circle.h b/src/intcgm/circle.h
new file mode 100644
index 0000000..3209c0f
--- /dev/null
+++ b/src/intcgm/circle.h
@@ -0,0 +1,3 @@
+int cgm_poly_circle ( double xc, double yc, double radius, double angi, double angf, int fechado );
+int cgm_line_circle ( double xc, double yc, double radius, double angi, double angf, int fechado );
+
diff --git a/src/intcgm/ellipse.c b/src/intcgm/ellipse.c
new file mode 100644
index 0000000..8d6889c
--- /dev/null
+++ b/src/intcgm/ellipse.c
@@ -0,0 +1,143 @@
+#include <stdio.h>
+#include <math.h>
+
+#include <cd.h>
+
+#include "list.h"
+#include "types.h"
+#include "intcgm.h"
+#include "intcgm6.h"
+#include "ellipse.h"
+
+#ifndef PI
+#define PI 3.14159265358979323846
+#endif
+
+#define ANGMIN 0.00001
+
+/* Adjust the circle parametrization for the elipsis parametrization */
+double cgm_AdjArc ( double arc, double w, double h )
+{
+ double value;
+
+ if ((fabs(w*sin(arc))<1e-99) && (fabs(h*cos(arc))<1e-99))
+   value = 0.0;
+ else
+   value = atan2(w*sin(arc), h*cos(arc));
+
+ if ( arc >  PI  ) value += 2*PI;
+ if ( arc < -PI  ) value -= 2*PI;
+
+ return value;
+}
+
+
+/*  Desenha um arco de Elipse */
+
+void cgm_ElpArc ( double xc, double yc, double w, double h, double r, double a1,
+              double a2, int n, int tipo )
+
+{
+
+ /* Onde:
+
+  (xc,yc) Centro
+  (w,h)   Largura e altura (diametro na direcao dos eixos principais)
+  r       Inclinacao dos eixos principais com relacao x e y
+  a1,a2   Angulos incial e final do arco [-360,+360]
+             Note-se que o sentido e' dado pela diferenca a2-a1,
+             ou seja, 30 a 330 e' trigonometrico
+                      30 a -30 e' horario
+  n       Numero de segmentos da poligonal equivalente
+          (64 parece ser um bom numero)
+  tipo    0=aberto 1=fechado(torta) 2=fechado(corda) */
+
+  double da, c, s, sx, sy, ang, xant, yant;
+  double px, py, tx, ty, txant, tyant, dx, dy;
+  int i, inicio;
+
+/* Reduz de diametro a raio */
+
+  w = w/2;
+  h = h/2;
+
+/* Transforma graus em radianos e ajusta a os angulos da parametrizacao */
+
+  a1 = cgm_AdjArc(a1,w,h);
+
+  a2 = cgm_AdjArc(a2,w,h);
+
+  if ( a2>a1 )
+   ang = a2 - a1;
+  else
+   ang = 2*PI - ( a1 - a2 );
+
+/* Gera os pontos do arco centrado na origem com os eixos em x e y */
+
+  da = ang/n;
+  c  = cos(da);
+  s  = sin(da);
+  sx = -w*s/h;
+  sy = h*s/w;
+
+  if ( tipo==1 || tipo==2 )
+   {
+    long int cor;
+    cor = cgm_getcolor ( intcgm_fill_att.color );
+    cdCanvasSetForeground (intcgm_canvas,  cor );
+    cdCanvasBegin(intcgm_canvas,  cgm_setintstyle(intcgm_fill_att.int_style) );
+   }
+  else
+   {
+    long int cor;
+    int size = (int)floor(intcgm_line_att.width+.5);
+    cdCanvasLineStyle (intcgm_canvas,  intcgm_line_att.type );
+    cdCanvasLineWidth (intcgm_canvas,  size>0? size: 1 );
+    cor = cgm_getcolor ( intcgm_line_att.color );
+    cdCanvasSetForeground (intcgm_canvas,  cor );
+   }
+
+  dx = (fabs(r)>ANGMIN) ? sin(r) : 0;
+  dy = (fabs(r)>ANGMIN) ? cos(r) : 1;
+
+  xant  = w*cos(a1);
+  yant  = h*sin(a1);
+
+  txant = xc+dy*xant-dx*yant;   /* Inclina (se for o caso) e translada */
+  tyant = yc+dx*xant+dy*yant;   /* Inclina (se for o caso) e translada */
+
+  if ( tipo==1 )
+   {
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(xc), cgm_vdcy2canvas(yc) );
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(txant), cgm_vdcy2canvas(tyant) );
+    inicio = 2;
+   }
+  else if ( tipo==2 )
+   {
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(txant), cgm_vdcy2canvas(tyant) );
+    inicio = 1;
+   }
+
+  for ( i=inicio; i<=(n+inicio-1); i++ )
+   {
+    px = c*xant+sx*yant;
+    py = sy*xant+c*yant;
+
+    tx = xc+dy*px-dx*py;       /* Inclina (se for o caso) e translada */
+    ty = yc+dx*px+dy*py;       /* Inclina (se for o caso) e translada */
+
+    if ( tipo==0 )
+     cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(txant), cgm_vdcy2canvas(tyant), cgm_vdcx2canvas(tx), cgm_vdcy2canvas(ty) );
+    else
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(tx), cgm_vdcy2canvas(ty) );
+
+    xant = px;
+    yant = py;
+    txant = tx;
+    tyant = ty;
+  }
+
+/* Desenha */
+
+  if ( tipo==1 || tipo==2 ) cdCanvasEnd(intcgm_canvas);
+}
diff --git a/src/intcgm/ellipse.h b/src/intcgm/ellipse.h
new file mode 100644
index 0000000..80980ff
--- /dev/null
+++ b/src/intcgm/ellipse.h
@@ -0,0 +1,3 @@
+void cgm_ElpArc ( double, double, double, double, double, double, double, int, int );
+double cgm_AdjArc ( double arc, double w, double h );
+
diff --git a/src/intcgm/intcgm.h b/src/intcgm/intcgm.h
new file mode 100644
index 0000000..c106ee0
--- /dev/null
+++ b/src/intcgm/intcgm.h
@@ -0,0 +1,84 @@
+typedef int (*CGM_FUNC) (void);
+
+#ifdef _INTCGM1_C_
+
+t_cgm intcgm_cgm;
+cdCanvas* intcgm_canvas = NULL;
+
+tlimit intcgm_vdc_ext;
+double intcgm_scale_factor_x;
+double intcgm_scale_factor_y;
+double intcgm_scale_factor_mm_x;
+double intcgm_scale_factor_mm_y;
+double intcgm_scale_factor;
+int intcgm_view_xmin, intcgm_view_ymin, intcgm_view_xmax, intcgm_view_ymax;
+double intcgm_clip_xmin, intcgm_clip_ymin, intcgm_clip_xmax, intcgm_clip_ymax;
+
+_line_att intcgm_line_att = { 1, LINE_SOLID, 1., {1} };
+
+_marker_att intcgm_marker_att = { 3, MARK_ASTERISK, 1., {1} };
+
+_text_att intcgm_text_att = { 1, 1, NULL, 0, CD_PLAIN, 8,  STRING, 1., 0., {1}, .1,
+                       {0,1}, {1,0}, PATH_RIGHT, {NORMHORIZ,NORMVERT,0.,0.} };
+
+_fill_att intcgm_fill_att = { 1, HOLLOW, {1}, 1, 1, {0,0}, NULL, {{0.,0.},{0.,0.}} };
+
+_edge_att intcgm_edge_att = { 1, EDGE_SOLID, 1., {1}, OFF };
+
+trgb *intcgm_color_table;
+int intcgm_block;
+
+TList *intcgm_asf_list;
+
+tpoint *intcgm_point_list;
+int intcgm_npoints;
+
+CGM_FUNC intcgm_funcs[] = { NULL, &cgmb_rch, &cgmt_rch };
+
+#else
+
+extern t_cgm intcgm_cgm;
+extern cdCanvas* intcgm_canvas;
+
+extern tlimit intcgm_vdc_ext;
+extern double intcgm_scale_factor_x;
+extern double intcgm_scale_factor_y;
+extern double intcgm_scale_factor_mm_x;
+extern double intcgm_scale_factor_mm_y;
+extern double intcgm_scale_factor;
+extern int intcgm_view_xmin, intcgm_view_ymin, intcgm_view_xmax, intcgm_view_ymax;
+extern double intcgm_clip_xmin, intcgm_clip_ymin, intcgm_clip_xmax, intcgm_clip_ymax;
+
+extern _line_att intcgm_line_att;
+
+extern _marker_att intcgm_marker_att;
+
+extern _text_att intcgm_text_att;
+
+extern _fill_att intcgm_fill_att;
+
+extern _edge_att intcgm_edge_att;
+
+extern trgb *intcgm_color_table;
+extern int intcgm_block;
+
+extern TList *intcgm_asf_list;
+
+extern tpoint *intcgm_point_list;
+extern int intcgm_npoints;
+
+extern CGM_FUNC *intcgm_funcs;
+
+#endif
+
+typedef struct _tasf {
+                     short type;
+                     short value;
+                    } tasf;
+
+typedef struct _pat_table {
+                           long index;
+                           long nx, ny;
+                           tcolor *pattern;
+                          } pat_table;
+
diff --git a/src/intcgm/intcgm1.c b/src/intcgm/intcgm1.c
new file mode 100644
index 0000000..d4b2399
--- /dev/null
+++ b/src/intcgm/intcgm1.c
@@ -0,0 +1,291 @@
+#define _INTCGM1_C_
+
+#include <stdio.h>      /* FILE, ftell, fseek, fputc, fopen, fclose, fputs, fprintf */
+#include <stdlib.h>     /* malloc, free */
+#include <string.h>     /* strlen */
+#include <math.h>       /* floor */
+
+#ifdef SunOS
+#include <unistd.h>       /* SEEK_SET, SEEK_END */
+#endif
+
+#include <float.h>      /* FLT_MIN, FLT_MAX */
+#include <limits.h>     /* INT_MIN, INT_MAX */
+
+#include "cd.h"
+#include "cdcgm.h"
+
+#include "list.h"
+#include "types.h"
+#include "intcgm2.h"
+#include "intcgm.h"
+#include "bparse.h"
+
+static int isitbin ( char *fname )
+{
+ unsigned char ch[2];
+ int erro, c, id;
+ unsigned short b;
+ FILE *f = fopen ( fname, "rb" );
+ if (!f)
+   return 0;
+
+ erro = fread ( ch, 1, 2, f );
+  
+ b = (ch[0] << 8) + ch[1];
+
+ id = ( b & 0x0FE0 ) >> 5;
+
+ c = ( b & 0xF000 ) >> 12;
+ 
+ fclose(f);
+ 
+ if ( c==0 && id==1 )
+  return 1;
+ else
+  return 0; 
+}
+
+static int cgmplay ( char* filename, int xmn, int xmx, int ymn, int ymx )
+{
+ intcgm_view_xmin = xmn;
+ intcgm_view_xmax = xmx;
+ intcgm_view_ymin = ymn;
+ intcgm_view_ymax = ymx;
+
+ intcgm_scale_factor_x = 1;
+ intcgm_scale_factor_y = 1;
+ intcgm_scale_factor   = 1;
+
+ intcgm_block = 500;
+ intcgm_npoints = 500;
+ intcgm_cgm.buff.size = 1024;
+
+ intcgm_point_list = (tpoint *) malloc ( sizeof(tpoint)*intcgm_npoints);
+ intcgm_cgm.buff.dados = (char *) malloc ( sizeof(char) * intcgm_cgm.buff.size );
+
+ if ( isitbin(filename) )
+ {
+   intcgm_cgm.fp = fopen ( filename, "rb" );
+   if (!intcgm_cgm.fp)
+   {
+     free(intcgm_point_list);
+     free(intcgm_cgm.buff.dados);
+     return CD_ERROR;
+   }
+
+   fseek ( intcgm_cgm.fp, 0, SEEK_END );
+   intcgm_cgm.file_size = ftell ( intcgm_cgm.fp );
+   fseek ( intcgm_cgm.fp, 0, SEEK_SET );
+
+   intcgm_cgm.mode = 1;
+   intcgm_cgm.cgmf = intcgm_funcs[intcgm_cgm.mode];
+
+   intcgm_cgm.int_prec.b_prec  = 1;
+   intcgm_cgm.real_prec.b_prec = 2;
+   intcgm_cgm.ix_prec.b_prec   = 1;
+   intcgm_cgm.cd_prec   = 0;
+   intcgm_cgm.cix_prec  = 0;
+   intcgm_cgm.vdc_int.b_prec  = 1;
+   intcgm_cgm.vdc_real.b_prec = 2;
+ }
+ else
+ {
+   intcgm_cgm.fp = fopen ( filename, "r" );
+   if (!intcgm_cgm.fp)
+   {
+     free(intcgm_point_list);
+     free(intcgm_cgm.buff.dados);
+     return CD_ERROR;
+   }
+
+   fseek ( intcgm_cgm.fp, 0, SEEK_END );
+   intcgm_cgm.file_size = ftell ( intcgm_cgm.fp );
+   fseek ( intcgm_cgm.fp, 0, SEEK_SET );
+
+   intcgm_cgm.mode = 2;
+   intcgm_cgm.cgmf = intcgm_funcs[intcgm_cgm.mode];
+
+   intcgm_cgm.int_prec.t_prec.minint  = -32767;
+   intcgm_cgm.int_prec.t_prec.maxint  = 32767;
+   intcgm_cgm.real_prec.t_prec.minreal = -32767;
+   intcgm_cgm.real_prec.t_prec.maxreal = 32767;
+   intcgm_cgm.real_prec.t_prec.digits = 4;
+   intcgm_cgm.ix_prec.t_prec.minint   = 0;
+   intcgm_cgm.ix_prec.t_prec.maxint   = 127;
+   intcgm_cgm.cd_prec   = 127;
+   intcgm_cgm.vdc_int.t_prec.minint  = -32767;
+   intcgm_cgm.vdc_int.t_prec.maxint  = 32767;
+   intcgm_cgm.vdc_real.t_prec.minreal = 0;
+   intcgm_cgm.vdc_real.t_prec.maxreal = 1;
+   intcgm_cgm.vdc_real.t_prec.digits = 4;
+ }
+
+ intcgm_cgm.first = 1;
+ intcgm_cgm.len = 0;
+ intcgm_cgm.vdc_type = INTEGER;
+ intcgm_cgm.max_cix = 63;
+ intcgm_cgm.scaling_mode.mode = ABSTRACT;
+ intcgm_cgm.scaling_mode.scale_factor = 1.;
+ intcgm_cgm.drawing_mode = ABSTRACT;
+ intcgm_cgm.clrsm = INDEXED;
+ intcgm_cgm.lnwsm = SCALED;
+ intcgm_cgm.mkssm = SCALED;
+ intcgm_cgm.edwsm = SCALED;
+ intcgm_cgm.vdc_ext.first.x = 0;
+ intcgm_cgm.vdc_ext.first.y = 0;
+ intcgm_cgm.vdc_ext.second.x = 32767;
+ intcgm_cgm.vdc_ext.second.y = 32767;
+ intcgm_cgm.back_color.red = 0;
+ intcgm_cgm.back_color.green = 0;
+ intcgm_cgm.back_color.blue = 0;
+ intcgm_cgm.aux_color.rgb.red = 0;
+ intcgm_cgm.aux_color.rgb.green = 0;
+ intcgm_cgm.aux_color.rgb.blue = 0;
+ intcgm_cgm.color_ext.black.red = 0;
+ intcgm_cgm.color_ext.black.green = 0;
+ intcgm_cgm.color_ext.black.blue = 0;
+ intcgm_cgm.color_ext.white.red = 255;
+ intcgm_cgm.color_ext.white.green = 255;
+ intcgm_cgm.color_ext.white.blue = 255;
+ intcgm_cgm.transparency = ON;
+ intcgm_cgm.clip_rect.first.x = 0;
+ intcgm_cgm.clip_rect.first.y = 0;
+ intcgm_cgm.clip_rect.second.x = 32767;
+ intcgm_cgm.clip_rect.second.y = 32767;
+ intcgm_cgm.clip_ind = ON;
+ intcgm_cgm.bc = 0;
+ intcgm_cgm.bl= 0;
+ intcgm_cgm.cl = 0;
+
+ intcgm_line_att.index = 1;
+ intcgm_line_att.type = LINE_SOLID;
+ intcgm_line_att.width = 1;
+ intcgm_line_att.color.ind = 1;
+
+ intcgm_marker_att.index = 1;
+ intcgm_marker_att.type = 1;
+ intcgm_marker_att.size = 1;
+ intcgm_marker_att.color.ind = 1;
+
+ intcgm_text_att.index = 1;
+ intcgm_text_att.font_index = 1;
+ intcgm_text_att.font_list = NULL;
+ intcgm_text_att.font = 0;
+ intcgm_text_att.style = CD_PLAIN;
+ intcgm_text_att.size = 8;
+ intcgm_text_att.prec = STRING;
+ intcgm_text_att.exp_fact = 1;
+ intcgm_text_att.char_spacing = 0;
+ intcgm_text_att.color.ind = 1;
+ intcgm_text_att.height = 1;
+ intcgm_text_att.char_up.x = 0;
+ intcgm_text_att.char_up.y = 1;
+ intcgm_text_att.char_base.x = 1;
+ intcgm_text_att.char_base.y = 0;
+ intcgm_text_att.path = PATH_RIGHT;
+ intcgm_text_att.alignment.hor = NORMHORIZ;
+ intcgm_text_att.alignment.ver  = NORMVERT;
+ intcgm_text_att.alignment.cont_hor = 0;
+ intcgm_text_att.alignment.cont_ver = 0;
+
+ intcgm_fill_att.index = 1;
+ intcgm_fill_att.int_style = HOLLOW;
+ intcgm_fill_att.color.ind = 1;
+ intcgm_fill_att.hatch_index = 1;
+ intcgm_fill_att.pat_index = 1;
+ intcgm_fill_att.ref_pt.x = 0;
+ intcgm_fill_att.ref_pt.y = 0;
+ intcgm_fill_att.pat_list = NULL;
+ intcgm_fill_att.pat_size.height.x = 0;
+ intcgm_fill_att.pat_size.height.y = 0;
+ intcgm_fill_att.pat_size.height.x = 0;
+ intcgm_fill_att.pat_size.width.y = 0;
+
+ intcgm_edge_att.index = 1;
+ intcgm_edge_att.type  = EDGE_SOLID;
+ intcgm_edge_att.width = 1;
+ intcgm_edge_att.color.ind = 1;
+ intcgm_edge_att.visibility = OFF;
+
+ cdCanvasLineWidth(intcgm_canvas, 1);
+
+ intcgm_color_table = (trgb *) malloc ( sizeof(trgb)*intcgm_cgm.max_cix);
+ intcgm_color_table[0].red   = 255;
+ intcgm_color_table[0].green = 255;
+ intcgm_color_table[0].blue  = 255;
+ intcgm_color_table[1].red   = 0;
+ intcgm_color_table[1].green = 0;
+ intcgm_color_table[1].blue  = 0;
+
+ while ( !(*intcgm_cgm.cgmf)() ){};
+
+ if ( intcgm_point_list!=NULL )
+ {
+   free(intcgm_point_list);
+   intcgm_point_list = NULL;
+ }
+
+ if ( intcgm_cgm.buff.dados!=NULL )
+ {
+   free(intcgm_cgm.buff.dados);
+   intcgm_cgm.buff.dados = NULL;
+ }
+
+ if ( intcgm_color_table!=NULL )
+ {
+   free(intcgm_color_table);
+   intcgm_color_table = NULL;
+ }
+
+ fclose(intcgm_cgm.fp);
+
+ return CD_OK;
+}
+
+_cdcgmsizecb cdcgmsizecb = NULL;
+_cdcgmbegmtfcb cdcgmbegmtfcb = NULL;
+_cdcgmcountercb cdcgmcountercb = NULL;
+_cdcgmsclmdecb cdcgmsclmdecb = NULL;
+_cdcgmvdcextcb cdcgmvdcextcb = NULL;
+_cdcgmbegpictcb cdcgmbegpictcb = NULL;
+_cdcgmbegpictbcb cdcgmbegpictbcb = NULL;
+
+int cdRegisterCallbackCGM(int cb, cdCallback func)
+{
+  switch (cb)
+  {
+  case CD_SIZECB:
+    cdcgmsizecb = (_cdcgmsizecb)func;
+    return CD_OK;
+  case CD_CGMBEGMTFCB:
+    cdcgmbegmtfcb = (_cdcgmbegmtfcb)func;
+    return CD_OK;
+  case CD_CGMCOUNTERCB:
+    cdcgmcountercb = (_cdcgmcountercb)func;
+    return CD_OK;
+  case CD_CGMSCLMDECB:
+    cdcgmsclmdecb = (_cdcgmsclmdecb)func;
+    return CD_OK;
+  case CD_CGMVDCEXTCB:
+    cdcgmvdcextcb = (_cdcgmvdcextcb)func;
+    return CD_OK;
+  case CD_CGMBEGPICTCB:
+    cdcgmbegpictcb = (_cdcgmbegpictcb)func;
+    return CD_OK;
+  case CD_CGMBEGPICTBCB:
+    cdcgmbegpictbcb = (_cdcgmbegpictbcb)func;
+    return CD_OK;
+  }
+  
+  return CD_ERROR;
+}
+
+int cdplayCGM(cdCanvas* _canvas, int xmin, int xmax, int ymin, int ymax, void *data)
+{
+  int ret;
+  intcgm_canvas = _canvas;
+  ret = cgmplay((char*)data, xmin, xmax, ymin, ymax);
+  _canvas = NULL;
+  return ret;
+}
diff --git a/src/intcgm/intcgm2.c b/src/intcgm/intcgm2.c
new file mode 100644
index 0000000..f16c916
--- /dev/null
+++ b/src/intcgm/intcgm2.c
@@ -0,0 +1,1653 @@
+#include <stdio.h>      /* FILE, ftell, fseek, fputc, fopen, fclose, fputs, fprintf */
+#include <string.h>     /* strlen */
+#include <stdlib.h>
+#include <ctype.h>
+#include <math.h>
+#include "cd.h"
+#include "cdcgm.h"
+#include "list.h"
+#include "types.h"
+#include "bparse.h"
+#include "tparse.h"
+#include "intcgm.h"
+#include "intcgm6.h"
+#include "tparse.h"
+
+typedef struct {
+                 const char *nome;
+				 int (*func) (void);
+               } comando;
+
+/**************************************************
+***************************************************
+**                                               **
+**                  FUNCOES CGM                  **
+**                                               **
+***************************************************
+**************************************************/
+
+/************************************************
+*                                               *
+*            Dados para nao-binario             *
+*                                               *
+************************************************/
+
+/* delimiter elements */
+
+comando _cgmt_NULL             = { "", NULL };
+comando _cgmt_BEGMF            = { "begmf", &cgmt_begmtf };
+comando _cgmt_ENDMF            = { "endmf", &cgmt_endmtf };
+comando _cgmt_BEG_PIC          = { "begpic", &cgmt_begpic };
+comando _cgmt_BEG_PIC_BODY     = { "begpicbody", &cgmt_begpib };
+comando _cgmt_END_PIC          = { "endpic", &cgmt_endpic };
+
+/* metafile descriptor elements */
+
+comando _cgmt_MF_VERSION       = { "mfversion", cgmt_mtfver };
+comando _cgmt_MF_DESC          = { "mfdesc", cgmt_mtfdsc };
+comando _cgmt_VDC_TYPE         = { "vdctype", cgmt_vdctyp };
+comando _cgmt_INTEGER_PREC     = { "integerprec", cgmt_intpre };
+comando _cgmt_REAL_PREC        = { "realprec", cgmt_realpr };
+comando _cgmt_INDEX_PREC       = { "indexprec", cgmt_indpre };
+comando _cgmt_COLR_PREC        = { "colrprec", cgmt_colpre };
+comando _cgmt_COLR_INDEX_PREC  = { "colrindexprec", cgmt_colipr };
+comando _cgmt_MAX_COLR_INDEX   = { "maxcolrindex", cgmt_maxcoi };
+comando _cgmt_COLR_VALUE_EXT   = { "colrvalueext", cgmt_covaex };
+comando _cgmt_MF_ELEM_LIST     = { "mfelemlist", cgmt_mtfell };
+comando _cgmt_BEG_MF_DEFAULTS  = { "begmfdefaults", cgmt_bmtfdf };
+comando _cgmt_END_MF_DEFAULTS  = { "endmfdefaults", cgmt_emtfdf };
+comando _cgmt_FONT_LIST        = { "fontlist", cgmt_fntlst };
+comando _cgmt_CHAR_SET_LIST    = { "charsetlist", cgmt_chslst };
+comando _cgmt_CHAR_CODING      = { "charcoding", cgmt_chcdac };
+
+/* picture descriptor elements */
+
+comando _cgmt_SCALE_MODE       = { "scalemode", cgmt_sclmde };
+comando _cgmt_COLR_MODE        = { "colrmode", cgmt_clslmd };
+comando _cgmt_LINE_WIDTH_MODE  = { "linewidthmode", cgmt_lnwdmd };
+comando _cgmt_MARKER_SIZE_MODE = { "markersizemode", cgmt_mkszmd };
+comando _cgmt_EDGE_WIDTH_MODE  = { "edgewidthmode", cgmt_edwdmd };
+comando _cgmt_VDC_EXTENT       = { "vdcext", cgmt_vdcext };
+comando _cgmt_BACK_COLR        = { "backcolr", cgmt_bckcol };
+
+/* control elements */
+
+comando _cgmt_VDC_INTEGER_PREC = { "vdcintegerprec", cgmt_vdcipr };
+comando _cgmt_VDC_REAL_PREC    = { "vdcrealprec", cgmt_vdcrpr };
+comando _cgmt_AUX_COLR         = { "auxcolr", cgmt_auxcol };
+comando _cgmt_TRANSPARENCY     = { "transparency", cgmt_transp };
+comando _cgmt_CLIP_RECT        = { "cliprect", cgmt_clprec };
+comando _cgmt_CLIP             = { "clip", cgmt_clpind };
+
+/* primitive elements */
+
+comando _cgmt_LINE             = { "line", cgmt_polyln };
+comando _cgmt_INCR_LINE        = { "incrline", cgmt_incply };
+comando _cgmt_DISJT_LINE       = { "disjtline", cgmt_djtply };
+comando _cgmt_INCR_DISJT_LINE  = { "incrdisjt_line", cgmt_indjpl };
+comando _cgmt_MARKER           = { "marker", cgmt_polymk };
+comando _cgmt_INCR_MARKER      = { "incrmarker", cgmt_incplm };
+comando _cgmt_TEXT             = { "text", cgmt_text };
+comando _cgmt_RESTR_TEXT       = { "restrtext", cgmt_rsttxt };
+comando _cgmt_APND_TEXT        = { "apndtext", cgmt_apdtxt };
+comando _cgmt_POLYGON          = { "polygon", cgmt_polygn };
+comando _cgmt_INCR_POLYGON     = { "incrpolygon", cgmt_incplg };
+comando _cgmt_POLYGON_SET      = { "polygonset", cgmt_plgset };
+comando _cgmt_INCR_POLYGON_SET = { "incrpolygonset", cgmt_inpgst };
+comando _cgmt_CELL_ARRAY       = { "cellarray", cgmt_cellar };
+comando _cgmt_GDP              = { "gdp", cgmt_gdp };
+comando _cgmt_RECT             = { "rect", cgmt_rect };
+comando _cgmt_CIRCLE           = { "circle", cgmt_circle };
+comando _cgmt_ARC_3_PT         = { "arc3pt", cgmt_circ3p };
+comando _cgmt_ARC_3_PT_CLOSE   = { "arc3ptclose", cgmt_cir3pc };
+comando _cgmt_ARC_CTR          = { "arcctr", cgmt_circnt };
+comando _cgmt_ARC_CTR_CLOSE    = { "arcctr_close", cgmt_ccntcl };
+comando _cgmt_ELLIPSE          = { "ellipse", cgmt_ellips };
+comando _cgmt_ELLIP_ARC        = { "elliparc", cgmt_ellarc };
+comando _cgmt_ELLIP_ARC_CLOSE  = { "elliparcclose", cgmt_ellacl };
+
+/* attribute elements */
+
+comando _cgmt_LINE_INDEX       = { "lineindex", cgmt_lnbdin };
+comando _cgmt_LINE_TYPE        = { "linetype", cgmt_lntype };
+comando _cgmt_LINE_WIDTH       = { "linewidth", cgmt_lnwidt };
+comando _cgmt_LINE_COLR        = { "linecolr", cgmt_lncolr };
+comando _cgmt_MARKER_INDEX     = { "markerindex", cgmt_mkbdin };
+comando _cgmt_MARKER_TYPE      = { "markertype", cgmt_mktype };
+comando _cgmt_MARKER_WIDTH     = { "markersize", cgmt_mksize };
+comando _cgmt_MARKER_COLR      = { "markercolr", cgmt_mkcolr };
+comando _cgmt_TEXT_INDEX       = { "textindex", cgmt_txbdin };
+comando _cgmt_TEXT_FONT_INDEX  = { "textfontindex", cgmt_txftin };
+comando _cgmt_TEXT_PREC        = { "textprec", cgmt_txtprc };
+comando _cgmt_CHAR_EXPAN       = { "charexpan", cgmt_chrexp };
+comando _cgmt_CHAR_SPACE       = { "charspace", cgmt_chrspc };
+comando _cgmt_TEXT_COLR        = { "textcolr", cgmt_txtclr };
+comando _cgmt_CHAR_HEIGHT      = { "charheight", cgmt_chrhgt };
+comando _cgmt_CHAR_ORI         = { "charori", cgmt_chrori };
+comando _cgmt_TEXT_PATH        = { "textpath", cgmt_txtpat };
+comando _cgmt_TEXT_ALIGN       = { "textalign", cgmt_txtali };
+comando _cgmt_CHAR_SET_INDEX   = { "charsetindex", cgmt_chseti };
+comando _cgmt_ALT_CHAR_SET     = { "altcharsetindex", cgmt_achsti };
+comando _cgmt_FILL_INDEX       = { "fillindex", cgmt_fillin };
+comando _cgmt_INT_STYLE        = { "intstyle", cgmt_intsty };
+comando _cgmt_FILL_COLR        = { "fillcolr", cgmt_fillco };
+comando _cgmt_HATCH_INDEX      = { "hatchindex", cgmt_hatind };
+comando _cgmt_PAT_INDEX        = { "patindex", cgmt_patind };
+comando _cgmt_EDGE_INDEX       = { "edgeindex", cgmt_edgind };
+comando _cgmt_EDGE_TYPE        = { "edgetype", cgmt_edgtyp };
+comando _cgmt_EDGE_WIDTH       = { "edgewidth", cgmt_edgwid };
+comando _cgmt_EDGE_COLR        = { "edgecolr", cgmt_edgcol };
+comando _cgmt_EDGE_VIS         = { "edgevis", cgmt_edgvis };
+comando _cgmt_FILL_REF_PT      = { "fillrefpt", cgmt_fillrf };
+comando _cgmt_PAT_TABLE        = { "pattable", cgmt_pattab };
+comando _cgmt_PAT_SIZE         = { "patsize", cgmt_patsiz };
+comando _cgmt_COLR_TABLE       = { "colrtable", cgmt_coltab };
+comando _cgmt_ASF              = { "asf", cgmt_asf };
+
+/* escape elements */
+
+comando _cgmt_ESCAPE           = { "escape", cgmt_escape };
+comando _cgmt_DOMAIN_RING      = { "domainring", NULL };
+
+/* external elements */
+
+comando _cgmt_MESSAGE          = { "message", cgmt_messag };
+comando _cgmt_APPL_DATA        = { "appldata", cgmt_appdta };
+
+comando *_cgmt_delimiter[] = {
+      &_cgmt_NULL,
+      &_cgmt_BEGMF,
+      &_cgmt_ENDMF,
+      &_cgmt_BEG_PIC,
+      &_cgmt_BEG_PIC_BODY,
+      &_cgmt_END_PIC,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+comando *_cgmt_metafile[] = {
+      &_cgmt_END_MF_DEFAULTS,
+      &_cgmt_MF_VERSION,
+      &_cgmt_MF_DESC,
+      &_cgmt_VDC_TYPE,
+      &_cgmt_INTEGER_PREC,
+      &_cgmt_REAL_PREC,
+      &_cgmt_INDEX_PREC,
+      &_cgmt_COLR_PREC,
+      &_cgmt_COLR_INDEX_PREC,
+      &_cgmt_MAX_COLR_INDEX,
+      &_cgmt_COLR_VALUE_EXT,
+      &_cgmt_MF_ELEM_LIST,
+      &_cgmt_BEG_MF_DEFAULTS,
+      &_cgmt_FONT_LIST,
+      &_cgmt_CHAR_SET_LIST,
+      &_cgmt_CHAR_CODING,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+comando *_cgmt_picture[] = {
+      &_cgmt_NULL,
+      &_cgmt_SCALE_MODE,
+      &_cgmt_COLR_MODE,
+      &_cgmt_LINE_WIDTH_MODE,
+      &_cgmt_MARKER_SIZE_MODE,
+      &_cgmt_EDGE_WIDTH_MODE,
+      &_cgmt_VDC_EXTENT,
+      &_cgmt_BACK_COLR,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL };
+
+comando *_cgmt_control[] = {
+      &_cgmt_NULL,
+      &_cgmt_VDC_INTEGER_PREC,
+      &_cgmt_VDC_REAL_PREC,
+      &_cgmt_AUX_COLR,
+      &_cgmt_TRANSPARENCY,
+      &_cgmt_CLIP_RECT,
+      &_cgmt_CLIP,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL, NULL, NULL };
+
+comando *_cgmt_primitive[] = {
+      &_cgmt_NULL,
+      &_cgmt_LINE,
+      &_cgmt_INCR_LINE,
+      &_cgmt_DISJT_LINE,
+      &_cgmt_INCR_DISJT_LINE,
+      &_cgmt_MARKER,
+      &_cgmt_INCR_MARKER,
+      &_cgmt_TEXT,
+      &_cgmt_RESTR_TEXT,
+      &_cgmt_APND_TEXT,
+      &_cgmt_POLYGON,
+      &_cgmt_INCR_POLYGON,
+      &_cgmt_POLYGON_SET,
+      &_cgmt_INCR_POLYGON_SET,
+      &_cgmt_CELL_ARRAY,
+      &_cgmt_GDP,
+      &_cgmt_RECT,
+      &_cgmt_CIRCLE,
+      &_cgmt_ARC_3_PT,
+      &_cgmt_ARC_3_PT_CLOSE,
+      &_cgmt_ARC_CTR,
+      &_cgmt_ARC_CTR_CLOSE,
+      &_cgmt_ELLIPSE,
+      &_cgmt_ELLIP_ARC,
+      &_cgmt_ELLIP_ARC_CLOSE,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+comando *_cgmt_attributes[] = {
+      &_cgmt_NULL,
+      &_cgmt_LINE_INDEX,
+      &_cgmt_LINE_TYPE,
+      &_cgmt_LINE_WIDTH,
+      &_cgmt_LINE_COLR,
+      &_cgmt_MARKER_INDEX,
+      &_cgmt_MARKER_TYPE,
+      &_cgmt_MARKER_WIDTH,
+      &_cgmt_MARKER_COLR,
+      &_cgmt_TEXT_INDEX,
+      &_cgmt_TEXT_FONT_INDEX,
+      &_cgmt_TEXT_PREC,
+      &_cgmt_CHAR_EXPAN,
+      &_cgmt_CHAR_SPACE,
+      &_cgmt_TEXT_COLR,
+      &_cgmt_CHAR_HEIGHT,
+      &_cgmt_CHAR_ORI,
+      &_cgmt_TEXT_PATH,
+      &_cgmt_TEXT_ALIGN,
+      &_cgmt_CHAR_SET_INDEX,
+      &_cgmt_ALT_CHAR_SET,
+      &_cgmt_FILL_INDEX,
+      &_cgmt_INT_STYLE,
+      &_cgmt_FILL_COLR,
+      &_cgmt_HATCH_INDEX,
+      &_cgmt_PAT_INDEX,
+      &_cgmt_EDGE_INDEX,
+      &_cgmt_EDGE_TYPE,
+      &_cgmt_EDGE_WIDTH,
+      &_cgmt_EDGE_COLR,
+      &_cgmt_EDGE_VIS,
+      &_cgmt_FILL_REF_PT,
+      &_cgmt_PAT_TABLE,
+      &_cgmt_PAT_SIZE,
+      &_cgmt_COLR_TABLE,
+      &_cgmt_ASF,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL };
+
+comando *_cgmt_escape[] = {
+      &_cgmt_NULL,
+      &_cgmt_ESCAPE,
+      &_cgmt_DOMAIN_RING,
+      NULL};
+
+comando *_cgmt_external[] = {
+      &_cgmt_NULL,
+      &_cgmt_MESSAGE,
+      &_cgmt_APPL_DATA,
+      NULL };
+
+comando *_cgmt_segment[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+comando *_cgmt_NULL_NULL[] = {
+      &_cgmt_NULL,
+	  NULL };
+		
+comando **_cgmt_comandos[] = {
+       _cgmt_NULL_NULL,
+       _cgmt_delimiter,
+       _cgmt_metafile,
+       _cgmt_picture,
+       _cgmt_control,
+       _cgmt_primitive,
+       _cgmt_attributes,
+       _cgmt_escape,
+       _cgmt_external,
+       _cgmt_segment,
+      NULL };
+
+/************************************************
+*                                               *
+*            Dados para binario                 *
+*                                               *
+************************************************/
+
+/* delimiter elements */
+
+CGM_FUNC _cgmb_NULL            = NULL;
+
+CGM_FUNC _cgmb_NOOP            = &cgmb_noop;
+CGM_FUNC _cgmb_BEGMF           = &cgmb_begmtf;
+CGM_FUNC _cgmb_ENDMF           = &cgmb_endmtf;
+CGM_FUNC _cgmb_BEG_PIC         = &cgmb_begpic;
+CGM_FUNC _cgmb_BEG_PIC_BODY    = &cgmb_begpib;
+CGM_FUNC _cgmb_END_PIC         = &cgmb_endpic;
+
+/* metafile descriptor elements */
+
+CGM_FUNC _cgmb_MF_VERSION       = &cgmb_mtfver;
+CGM_FUNC _cgmb_MF_DESC          = &cgmb_mtfdsc;
+CGM_FUNC _cgmb_VDC_TYPE         = &cgmb_vdctyp;
+CGM_FUNC _cgmb_INTEGER_PREC     = &cgmb_intpre;
+CGM_FUNC _cgmb_REAL_PREC        = &cgmb_realpr;
+CGM_FUNC _cgmb_INDEX_PREC       = &cgmb_indpre;
+CGM_FUNC _cgmb_COLR_PREC        = &cgmb_colpre;
+CGM_FUNC _cgmb_COLR_INDEX_PREC  = &cgmb_colipr;
+CGM_FUNC _cgmb_MAX_COLR_INDEX   = &cgmb_maxcoi;
+CGM_FUNC _cgmb_COLR_VALUE_EXT   = &cgmb_covaex;
+CGM_FUNC _cgmb_MF_ELEM_LIST     = &cgmb_mtfell;
+CGM_FUNC _cgmb_MF_DEFAULTS_RPL  = &cgmb_bmtfdf;
+CGM_FUNC _cgmb_FONT_LIST        = &cgmb_fntlst;
+CGM_FUNC _cgmb_CHAR_SET_LIST    = &cgmb_chslst;
+CGM_FUNC _cgmb_CHAR_CODING      = &cgmb_chcdac;
+
+/* picture descriptor elements */
+
+CGM_FUNC _cgmb_SCALE_MODE       = &cgmb_sclmde;
+CGM_FUNC _cgmb_COLR_MODE        = &cgmb_clslmd;
+CGM_FUNC _cgmb_LINE_WIDTH_MODE  = &cgmb_lnwdmd;
+CGM_FUNC _cgmb_MARKER_SIZE_MODE = &cgmb_mkszmd;
+CGM_FUNC _cgmb_EDGE_WIDTH_MODE  = &cgmb_edwdmd;
+CGM_FUNC _cgmb_VDC_EXTENT       = &cgmb_vdcext;
+CGM_FUNC _cgmb_BACK_COLR        = &cgmb_bckcol;
+
+/* control elements */
+
+CGM_FUNC _cgmb_VDC_INTEGER_PREC = &cgmb_vdcipr;
+CGM_FUNC _cgmb_VDC_REAL_PREC    = &cgmb_vdcrpr;
+CGM_FUNC _cgmb_AUX_COLR         = &cgmb_auxcol;
+CGM_FUNC _cgmb_TRANSPARENCY     = &cgmb_transp;
+CGM_FUNC _cgmb_CLIP_RECT        = &cgmb_clprec;
+CGM_FUNC _cgmb_CLIP             = &cgmb_clpind;
+
+/* primitive elements */
+
+CGM_FUNC _cgmb_LINE             = &cgmb_polyln;
+CGM_FUNC _cgmb_DISJT_LINE       = &cgmb_djtply;
+CGM_FUNC _cgmb_MARKER           = &cgmb_polymk;
+CGM_FUNC _cgmb_TEXT             = &cgmb_text;
+CGM_FUNC _cgmb_RESTR_TEXT       = &cgmb_rsttxt;
+CGM_FUNC _cgmb_APND_TEXT        = &cgmb_apdtxt;
+CGM_FUNC _cgmb_POLYGON          = &cgmb_polygn;
+CGM_FUNC _cgmb_POLYGON_SET      = &cgmb_plgset;
+CGM_FUNC _cgmb_CELL_ARRAY       = &cgmb_cellar;
+CGM_FUNC _cgmb_GDP              = &cgmb_gdp;
+CGM_FUNC _cgmb_RECT             = &cgmb_rect;
+CGM_FUNC _cgmb_CIRCLE           = &cgmb_circle;
+CGM_FUNC _cgmb_ARC_3_PT         = &cgmb_circ3p;
+CGM_FUNC _cgmb_ARC_3_PT_CLOSE   = &cgmb_cir3pc;
+CGM_FUNC _cgmb_ARC_CTR          = &cgmb_circnt;
+CGM_FUNC _cgmb_ARC_CTR_CLOSE    = &cgmb_ccntcl;
+CGM_FUNC _cgmb_ELLIPSE          = &cgmb_ellips;
+CGM_FUNC _cgmb_ELLIP_ARC        = &cgmb_ellarc;
+CGM_FUNC _cgmb_ELLIP_ARC_CLOSE  = &cgmb_ellacl;
+
+/* attribute elements */
+
+CGM_FUNC _cgmb_LINE_INDEX       = &cgmb_lnbdin;
+CGM_FUNC _cgmb_LINE_TYPE        = &cgmb_lntype;
+CGM_FUNC _cgmb_LINE_WIDTH       = &cgmb_lnwidt;
+CGM_FUNC _cgmb_LINE_COLR        = &cgmb_lncolr;
+CGM_FUNC _cgmb_MARKER_INDEX     = &cgmb_mkbdin;
+CGM_FUNC _cgmb_MARKER_TYPE      = &cgmb_mktype;
+CGM_FUNC _cgmb_MARKER_WIDTH     = &cgmb_mksize;
+CGM_FUNC _cgmb_MARKER_COLR      = &cgmb_mkcolr;
+CGM_FUNC _cgmb_TEXT_INDEX       = &cgmb_txbdin;
+CGM_FUNC _cgmb_TEXT_FONT_INDEX  = &cgmb_txftin;
+CGM_FUNC _cgmb_TEXT_PREC        = &cgmb_txtprc;
+CGM_FUNC _cgmb_CHAR_EXPAN       = &cgmb_chrexp;
+CGM_FUNC _cgmb_CHAR_SPACE       = &cgmb_chrspc;
+CGM_FUNC _cgmb_TEXT_COLR        = &cgmb_txtclr;
+CGM_FUNC _cgmb_CHAR_HEIGHT      = &cgmb_chrhgt;
+CGM_FUNC _cgmb_CHAR_ORI         = &cgmb_chrori;
+CGM_FUNC _cgmb_TEXT_PATH        = &cgmb_txtpat;
+CGM_FUNC _cgmb_TEXT_ALIGN       = &cgmb_txtali;
+CGM_FUNC _cgmb_CHAR_SET_INDEX   = &cgmb_chseti;
+CGM_FUNC _cgmb_ALT_CHAR_SET     = &cgmb_achsti;
+CGM_FUNC _cgmb_FILL_INDEX       = &cgmb_fillin;
+CGM_FUNC _cgmb_INT_STYLE        = &cgmb_intsty;
+CGM_FUNC _cgmb_FILL_COLR        = &cgmb_fillco;
+CGM_FUNC _cgmb_HATCH_INDEX      = &cgmb_hatind;
+CGM_FUNC _cgmb_PAT_INDEX        = &cgmb_patind;
+CGM_FUNC _cgmb_EDGE_INDEX       = &cgmb_edgind;
+CGM_FUNC _cgmb_EDGE_TYPE        = &cgmb_edgtyp;
+CGM_FUNC _cgmb_EDGE_WIDTH       = &cgmb_edgwid;
+CGM_FUNC _cgmb_EDGE_COLR        = &cgmb_edgcol;
+CGM_FUNC _cgmb_EDGE_VIS         = &cgmb_edgvis;
+CGM_FUNC _cgmb_FILL_REF_PT      = &cgmb_fillrf;
+CGM_FUNC _cgmb_PAT_TABLE        = &cgmb_pattab;
+CGM_FUNC _cgmb_PAT_SIZE         = &cgmb_patsiz;
+CGM_FUNC _cgmb_COLR_TABLE       = &cgmb_coltab;
+CGM_FUNC _cgmb_ASF              = &cgmb_asf;
+
+/* escape elements */
+
+CGM_FUNC _cgmb_ESCAPE           = &cgmb_escape;
+
+/* external elements */
+
+CGM_FUNC _cgmb_MESSAGE          = &cgmb_messag;
+CGM_FUNC _cgmb_APPL_DATA        = &cgmb_appdta;
+
+CGM_FUNC *_cgmb_delimiter[] = {
+      &_cgmb_NOOP,
+      &_cgmb_BEGMF,
+      &_cgmb_ENDMF,
+      &_cgmb_BEG_PIC,
+      &_cgmb_BEG_PIC_BODY,
+      &_cgmb_END_PIC,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+CGM_FUNC *_cgmb_metafile[] = {
+      &_cgmb_NULL,
+      &_cgmb_MF_VERSION,
+      &_cgmb_MF_DESC,
+      &_cgmb_VDC_TYPE,
+      &_cgmb_INTEGER_PREC,
+      &_cgmb_REAL_PREC,
+      &_cgmb_INDEX_PREC,
+      &_cgmb_COLR_PREC,
+      &_cgmb_COLR_INDEX_PREC,
+      &_cgmb_MAX_COLR_INDEX,
+      &_cgmb_COLR_VALUE_EXT,
+      &_cgmb_MF_ELEM_LIST,
+      &_cgmb_MF_DEFAULTS_RPL,
+      &_cgmb_FONT_LIST,
+      &_cgmb_CHAR_SET_LIST,
+      &_cgmb_CHAR_CODING,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+CGM_FUNC *_cgmb_picture[] = {
+      &_cgmb_NULL,
+      &_cgmb_SCALE_MODE,
+      &_cgmb_COLR_MODE,
+      &_cgmb_LINE_WIDTH_MODE,
+      &_cgmb_MARKER_SIZE_MODE,
+      &_cgmb_EDGE_WIDTH_MODE,
+      &_cgmb_VDC_EXTENT,
+      &_cgmb_BACK_COLR,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL };
+
+CGM_FUNC *_cgmb_control[] = {
+      &_cgmb_NULL,
+      &_cgmb_VDC_INTEGER_PREC,
+      &_cgmb_VDC_REAL_PREC,
+      &_cgmb_AUX_COLR,
+      &_cgmb_TRANSPARENCY,
+      &_cgmb_CLIP_RECT,
+      &_cgmb_CLIP,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL, NULL, NULL };
+
+CGM_FUNC *_cgmb_primitive[] = {
+      &_cgmb_NULL,
+      &_cgmb_LINE,
+      &_cgmb_DISJT_LINE,
+      &_cgmb_MARKER,
+      &_cgmb_TEXT,
+      &_cgmb_RESTR_TEXT,
+      &_cgmb_APND_TEXT,
+      &_cgmb_POLYGON,
+      &_cgmb_POLYGON_SET,
+      &_cgmb_CELL_ARRAY,
+      &_cgmb_GDP,
+      &_cgmb_RECT,
+      &_cgmb_CIRCLE,
+      &_cgmb_ARC_3_PT,
+      &_cgmb_ARC_3_PT_CLOSE,
+      &_cgmb_ARC_CTR,
+      &_cgmb_ARC_CTR_CLOSE,
+      &_cgmb_ELLIPSE,
+      &_cgmb_ELLIP_ARC,
+      &_cgmb_ELLIP_ARC_CLOSE,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+CGM_FUNC *_cgmb_attributes[] = {
+      &_cgmb_NULL,
+      &_cgmb_LINE_INDEX,
+      &_cgmb_LINE_TYPE,
+      &_cgmb_LINE_WIDTH,
+      &_cgmb_LINE_COLR,
+      &_cgmb_MARKER_INDEX,
+      &_cgmb_MARKER_TYPE,
+      &_cgmb_MARKER_WIDTH,
+      &_cgmb_MARKER_COLR,
+      &_cgmb_TEXT_INDEX,
+      &_cgmb_TEXT_FONT_INDEX,
+      &_cgmb_TEXT_PREC,
+      &_cgmb_CHAR_EXPAN,
+      &_cgmb_CHAR_SPACE,
+      &_cgmb_TEXT_COLR,
+      &_cgmb_CHAR_HEIGHT,
+      &_cgmb_CHAR_ORI,
+      &_cgmb_TEXT_PATH,
+      &_cgmb_TEXT_ALIGN,
+      &_cgmb_CHAR_SET_INDEX,
+      &_cgmb_ALT_CHAR_SET,
+      &_cgmb_FILL_INDEX,
+      &_cgmb_INT_STYLE,
+      &_cgmb_FILL_COLR,
+      &_cgmb_HATCH_INDEX,
+      &_cgmb_PAT_INDEX,
+      &_cgmb_EDGE_INDEX,
+      &_cgmb_EDGE_TYPE,
+      &_cgmb_EDGE_WIDTH,
+      &_cgmb_EDGE_COLR,
+      &_cgmb_EDGE_VIS,
+      &_cgmb_FILL_REF_PT,
+      &_cgmb_PAT_TABLE,
+      &_cgmb_PAT_SIZE,
+      &_cgmb_COLR_TABLE,
+      &_cgmb_ASF,
+      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+      NULL, NULL, NULL, NULL };
+
+CGM_FUNC *_cgmb_escape[] = {
+      &_cgmb_NULL,
+      &_cgmb_ESCAPE,
+      NULL};
+
+CGM_FUNC *_cgmb_external[] = {
+      &_cgmb_NULL,
+      &_cgmb_MESSAGE,
+      &_cgmb_APPL_DATA,
+      NULL };
+
+CGM_FUNC *_cgmb_segment[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+CGM_FUNC **_cgmb_comandos[] = {
+       _cgmb_delimiter,
+       _cgmb_metafile,
+       _cgmb_picture,
+       _cgmb_control,
+       _cgmb_primitive,
+       _cgmb_attributes,
+       _cgmb_escape,
+       _cgmb_external,
+       _cgmb_segment,
+       NULL };
+
+/************************************************
+*                                               *
+*             Funcoes para binario              *
+*                                               *
+************************************************/
+
+int cgm_getfilepos ( void )
+{
+ if (cdcgmcountercb)
+  return cdcgmcountercb ( intcgm_canvas, (ftell ( intcgm_cgm.fp )*100.)/intcgm_cgm.file_size );
+  
+ return 0; 
+}
+
+#define cgmb_getw cgmb_getu16
+#define cgmb_getb(b) cgmb_getc((unsigned char *)(b))
+
+static void cgmb_donothing ( void )
+{
+ intcgm_cgm.bc=intcgm_cgm.len;
+}
+
+int cgmb_exec_comand ( int classe, int id )
+{
+ int err;
+
+ if ( _cgmb_comandos[classe][id]==NULL )
+  {
+   cgmb_donothing();
+   return 0;
+  }
+
+ err = (*_cgmb_comandos[classe][id])();
+
+ if ( err == -1 )
+  return 1;
+ else if ( err )
+  {
+   cgmb_donothing();
+   return 0;
+  }
+
+ return 0;
+}
+
+int cgmb_getbit ( unsigned char *b )
+{
+ static unsigned char b1;
+
+ if ( intcgm_cgm.pc==0 || intcgm_cgm.pc==8 )
+  {
+   b1 = intcgm_cgm.buff.dados[intcgm_cgm.bc];
+   intcgm_cgm.bc++;
+
+   if ( intcgm_cgm.bc > intcgm_cgm.len )
+   {
+    return 1;
+   }
+
+   intcgm_cgm.pc=0;
+  }
+
+ *b = b1;
+
+ switch ( intcgm_cgm.pc )
+  {
+   case 0:
+    *b = ( *b | 0x0080 ) >> 7;
+    break;
+   case 1:
+    *b = ( *b | 0x0040 ) >> 6;
+    break;
+   case 2:
+    *b = ( *b | 0x0020 ) >> 5;
+    break;
+   case 3:
+    *b = ( *b | 0x0010 ) >> 4;
+    break;
+   case 4:
+    *b = ( *b | 0x0008 ) >> 3;
+    break;
+   case 5:
+    *b = ( *b | 0x0004 ) >> 2;
+    break;
+   case 6:
+    *b = ( *b | 0x0002 ) >> 1;
+    break;
+   case 7:
+    *b = ( *b | 0x0001 );
+    break;
+  }
+
+ intcgm_cgm.pc++;
+
+ return 0;
+}
+
+int cgmb_get2bit ( unsigned char *b )
+{
+ static unsigned char b1;
+
+ if ( intcgm_cgm.pc==0 || intcgm_cgm.pc==8 )
+  {
+   b1 = intcgm_cgm.buff.dados[intcgm_cgm.bc];
+   intcgm_cgm.bc++;
+
+   if ( intcgm_cgm.bc > intcgm_cgm.len ) return 1;
+
+   intcgm_cgm.pc=0;
+  }
+
+ *b = b1;
+
+ switch ( intcgm_cgm.pc )
+  {
+   case 0:
+    *b = ( *b | 0x00C0 ) >> 6;
+    break;
+   case 2:
+    *b = ( *b | 0x0030 ) >> 4;
+    break;
+   case 4:
+    *b = ( *b | 0x000C ) >> 2;
+    break;
+   case 6:
+    *b = ( *b | 0x0003 );
+    break;
+  }
+
+ intcgm_cgm.pc += 2;
+
+ return 0;
+}
+
+
+int cgmb_get4bit ( unsigned char *b )
+{
+ static unsigned char b1;
+
+ if ( intcgm_cgm.pc==0 || intcgm_cgm.pc==8 )
+  {
+   b1 = intcgm_cgm.buff.dados[intcgm_cgm.bc];
+   intcgm_cgm.bc++;
+
+   if ( intcgm_cgm.bc > intcgm_cgm.len ) return 1;
+
+   intcgm_cgm.pc=0;
+  }
+
+ *b = b1;
+
+ switch ( intcgm_cgm.pc )
+  {
+   case 0:
+    *b = ( *b | 0x00F0 ) >> 4;
+    break;
+   case 4:
+    *b = ( *b | 0x000F );
+    break;
+  }
+
+ intcgm_cgm.pc += 4;
+
+ return 0;
+}
+
+int cgmb_getw ( unsigned short * );
+
+int cgmb_getc ( unsigned char *b )
+{
+ *b = intcgm_cgm.buff.dados[intcgm_cgm.bc];
+ intcgm_cgm.bc++;
+
+ if ( intcgm_cgm.bc > intcgm_cgm.len ) return 1;
+ 
+ return 0;   
+}
+
+int cgmb_geti8  ( signed char *b )
+{
+ unsigned char b1;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+
+ *b = (signed char) b1;
+ 
+ return 0;
+}
+
+int cgmb_geti16 ( short *b )
+{
+ unsigned char b1, b2;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+
+ *b = ( b1<<8 ) | b2;
+
+ return 0;
+}
+
+int cgmb_geti24 ( long *b )
+{
+ unsigned char b1, b2, b3;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+ if ( cgmb_getb ( &b3 ) ) return 1;
+
+ *b = ( b1<<16 ) | ( b2<<8 ) | b3;
+
+ return 0;
+}
+
+int cgmb_geti32 ( long *b )
+{
+ unsigned char b1, b2, b3, b4;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+ if ( cgmb_getb ( &b3 ) ) return 1;
+ if ( cgmb_getb ( &b4 ) ) return 1;
+
+ *b = ( b1<<24 ) | ( b2<<16 ) | ( b3<<8 ) | b4;
+
+ return 0;
+}
+
+int cgmb_getu8  ( unsigned char *b )
+{
+ if ( cgmb_getb ( b ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_getu16 ( unsigned short *b )
+{
+ unsigned char b1, b2;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+
+ *b = ( b1<<8 ) | b2;
+
+ return 0;
+}
+
+int cgmb_getu24 ( unsigned long *b )
+{
+ unsigned char b1, b2, b3;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+ if ( cgmb_getb ( &b3 ) ) return 1;
+
+ *b = ( b1<<16 ) | ( b2<<8 ) | b3;
+
+ return 0;
+}
+
+int cgmb_getu32 ( unsigned long *b )
+{
+ unsigned char b1, b2, b3, b4;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+ if ( cgmb_getb ( &b3 ) ) return 1;
+ if ( cgmb_getb ( &b4 ) ) return 1;
+
+ *b = ( b1<<24 ) | ( b2<<16 ) | ( b3<<8 ) | b4;
+
+ return 0;
+}
+
+int cgmb_getfl32 ( float *b )
+{
+ unsigned char b1, b2, b3, b4;
+ union {
+        float f;
+        long  l;
+       } r;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+ if ( cgmb_getb ( &b3 ) ) return 1;
+ if ( cgmb_getb ( &b4 ) ) return 1;
+
+ r.l = ( b1<<24 ) | ( b2<<16 ) | ( b3<<8 ) | b4;
+ *b = r.f;
+
+ return 0;
+}
+
+int cgmb_getfl64 ( double *b )
+{
+ unsigned char b1, b2, b3, b4, b5, b6, b7, b8;
+ union {
+        double d;
+        long   l[2];
+       } r;
+
+ if ( cgmb_getb ( &b1 ) ) return 1;
+ if ( cgmb_getb ( &b2 ) ) return 1;
+ if ( cgmb_getb ( &b3 ) ) return 1;
+ if ( cgmb_getb ( &b4 ) ) return 1;
+ if ( cgmb_getb ( &b5 ) ) return 1;
+ if ( cgmb_getb ( &b6 ) ) return 1;
+ if ( cgmb_getb ( &b7 ) ) return 1;
+ if ( cgmb_getb ( &b8 ) ) return 1;
+
+ r.l[1] = ( b1<<24 ) | ( b2<<16 ) | ( b3<<8 ) | b4;
+ r.l[0] = ( b5<<24 ) | ( b6<<16 ) | ( b7<<8 ) | b8;
+ *b = r.d;
+
+ return 0;
+}
+
+int cgmb_getfx32 ( float *b )
+{
+ short si;
+ unsigned short ui;
+
+ if ( cgmb_geti16 ( &si ) ) return 1;
+ if ( cgmb_getu16 ( &ui ) ) return 1;
+
+ *b = (float) ( si + ( ui / 65536.0 ) );
+
+ return 0;
+}
+
+int cgmb_getfx64 ( double *b )
+{
+ long si, ui;
+
+ if ( cgmb_geti32 ( &si ) ) return 1;
+ if ( cgmb_geti32 ( &ui ) ) return 1;
+
+ *b = si + ( (unsigned short) ui / ( 65536.0 * 65536.0 ) );
+
+ return 0;
+}
+
+int cgmb_ter ( void )
+{
+ return 0;
+}
+
+int cgmb_rch ( void )
+{
+ int c, id, len, cont, i; 
+ unsigned char ch[2], dummy;
+ unsigned short b;
+ int erro;
+
+ if ( intcgm_cgm.bc!=intcgm_cgm.len )
+  {
+   return 1;
+  }
+
+ intcgm_cgm.bc = 0;
+
+ erro = fread ( ch, 1, 2, intcgm_cgm.fp );
+ if ( erro<2 ) return 1;
+
+ intcgm_cgm.bl += 2;
+
+ b = (ch[0] << 8) + ch[1];
+
+ len = b & 0x001F;
+
+ id = ( b & 0x0FE0 ) >> 5;
+
+ c = ( b & 0xF000 ) >> 12;
+
+ cont = 0;
+
+ if ( len > 30 )
+  {
+   erro = fread ( ch, 1, 2, intcgm_cgm.fp );
+   if ( erro<2 ) return 1;
+
+   intcgm_cgm.bl += 2;
+
+   b = (ch[0] << 8) + ch[1];
+
+   len = b & 0x7FFF;
+   cont = ( b & 0x8000 );
+  }
+
+ intcgm_cgm.len = len;
+
+ if ( intcgm_cgm.len )
+  {
+   if ( intcgm_cgm.len>intcgm_cgm.buff.size )
+     intcgm_cgm.buff.dados = (char *) realloc ( intcgm_cgm.buff.dados, sizeof(char) * intcgm_cgm.len );
+
+   erro = fread ( intcgm_cgm.buff.dados, 1, intcgm_cgm.len, intcgm_cgm.fp );
+   if ( erro<intcgm_cgm.len ) return 1;
+
+   intcgm_cgm.bl += intcgm_cgm.len;
+
+   if ( len & 1 )
+    {
+     erro = fread ( &dummy, 1, 1, intcgm_cgm.fp );
+     if ( erro<1 ) return 1;
+
+     intcgm_cgm.bl += 1;
+    }
+
+   while ( cont )
+    {
+     unsigned char ch[2];
+     unsigned short b;
+     int old_len = intcgm_cgm.len;
+
+     erro = fread ( ch, 1, 2, intcgm_cgm.fp );
+     if ( erro<2 ) return 1;
+
+     intcgm_cgm.bl += 2;
+
+     b = (ch[0] << 8) + ch[1];
+
+     cont = ( b & 0x8000 );
+
+     len = b & 0x7fff;
+
+     intcgm_cgm.len += len;
+
+     if ( intcgm_cgm.len>intcgm_cgm.buff.size )
+       intcgm_cgm.buff.dados = (char *) realloc ( (char *)intcgm_cgm.buff.dados, sizeof(char) * intcgm_cgm.len );
+
+     erro = fread ( &intcgm_cgm.buff.dados[old_len], 1, len, intcgm_cgm.fp );
+     if ( erro<len ) return 1;
+
+     if ( len & 1 )
+      {
+       erro = fread ( &dummy, 1, 1, intcgm_cgm.fp );
+       if ( erro<1 ) return 1;
+       intcgm_cgm.bl += 1;
+      }
+    }
+  }
+
+ cgm_getfilepos ();
+
+ if ( cgmb_exec_comand ( c, id ) ) return 1;
+
+ for ( i=0; i<intcgm_cgm.len-intcgm_cgm.bc; i++ )
+  {
+   unsigned char dummy;
+   if ( cgmb_getb ( &dummy ) ) return 1;
+  }
+
+ return 0;
+}
+
+int cgmb_ci ( unsigned long *ci )
+{
+ unsigned char c;
+ unsigned short i;
+
+ switch ( intcgm_cgm.cix_prec )
+  {
+   case 0: if ( cgmb_getu8  ( &c ) ) return 1; 
+           *ci = (unsigned long) c;
+           break;
+   case 1: if ( cgmb_getu16 ( &i ) ) return 1;
+           *ci = (unsigned long) i;
+           break;
+   case 2: if ( cgmb_getu24 ( ci ) ) return 1;
+           break;
+   case 3: if ( cgmb_getu32 ( ci ) ) return 1;
+           break;
+  }
+
+ return 0;
+}
+
+int cgmb_cd ( unsigned long *cd )
+{
+ unsigned char c;
+ unsigned short i;
+
+ switch ( intcgm_cgm.cd_prec )
+  {
+   case 0: if ( cgmb_getu8  ( &c ) ) return 1;
+           *cd = (unsigned long) c;
+           break;
+   case 1: if ( cgmb_getu16 ( &i ) ) return 1;
+           *cd = (unsigned long) i;
+           break;
+   case 2: if ( cgmb_getu24 ( cd ) ) return 1;
+           break;
+   case 3: if ( cgmb_getu32 ( cd ) ) return 1;
+           break;
+  }
+
+ return 0;
+}
+
+int cgmb_rgb ( unsigned long *r, unsigned long *g, unsigned long *b )
+{
+ if ( cgmb_cd ( r ) ) return 1;
+ if ( cgmb_cd ( g ) ) return 1;
+ if ( cgmb_cd ( b ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_ix ( long *ix )
+{
+ signed char c;
+ short i;
+
+ switch ( intcgm_cgm.ix_prec.b_prec )
+  {
+   case 0: if ( cgmb_geti8  ( &c ) ) return 1;
+           *ix = (long) c;
+           break;
+   case 1: if ( cgmb_geti16 ( &i ) ) return 1;
+           *ix = (long) i;
+           break;
+   case 2: if ( cgmb_geti24 ( ix ) ) return 1;
+           break;
+   case 3: if ( cgmb_geti32 ( ix ) ) return 1;
+           break;
+  }
+
+ return 0;
+}
+
+int cgmb_e ( short *e )
+{
+ return cgmb_geti16 ( e );
+}
+
+int cgmb_i ( long *li )
+{
+ signed char c;
+ short i;
+
+ switch ( intcgm_cgm.int_prec.b_prec )
+  {
+   case 0: if ( cgmb_geti8  ( &c ) ) return 1;
+           *li = (long) c;
+           break;
+   case 1: if ( cgmb_geti16 ( &i ) ) return 1;
+           *li = (long) i;
+           break;
+   case 2: if ( cgmb_geti24 ( li ) ) return 1;
+           break;
+   case 3: if ( cgmb_geti32 ( li ) ) return 1;
+           break;
+  }
+
+ return 0;
+}
+
+int cgmb_u ( unsigned long *ui )
+{
+ unsigned char c;
+ unsigned short i;
+
+ switch ( intcgm_cgm.int_prec.b_prec )
+  {
+   case 0: if ( cgmb_getu8  ( &c ) ) return 1;
+           *ui = (unsigned long) c;
+           break;
+   case 1: if ( cgmb_getu16 ( &i ) ) return 1;
+           *ui = (unsigned long) i;
+           break;
+   case 2: if ( cgmb_getu24 ( ui ) ) return 1;
+           break;
+   case 3: if ( cgmb_getu32 ( ui ) ) return 1;
+           break;
+  }
+
+ return 0;
+}
+
+int cgmb_r ( double *d )
+{
+ float f;
+
+ switch ( intcgm_cgm.real_prec.b_prec )
+  {
+   case 0: if ( cgmb_getfl32 ( &f ) ) return 1;
+           *d = (double) f;
+           break;
+   case 1: if ( cgmb_getfl64 ( d ) ) return 1;
+           break;
+   case 2: if ( cgmb_getfx32 ( &f ) ) return 1;
+           *d = (double) f;
+           break;
+   case 3: if ( cgmb_getfx64 ( d ) ) return 1;
+           break;
+  }
+
+ return 0;
+}
+
+int cgmb_s ( char **str )
+{
+ register unsigned i;
+ unsigned char l;
+ unsigned short l1;
+ unsigned short cont;
+ char *s = NULL;
+
+ cont = 1;
+
+ if ( cgmb_getu8 ( &l ) ) return 1;
+
+ l1 = l;
+
+ while ( cont )
+  {
+   if ( l > 254 )
+    {
+     if ( cgmb_getu16 ( &l1 ) ) return 1;
+     cont = ( l1 & 0x8000);
+     l1 &= 0x7fff;
+    }
+   else
+    cont = 0;
+
+   s = (char *)realloc ( (unsigned char *)s, (sizeof ( char ) * l1) + 1 );
+ 
+   for ( i=0; i<l1; i++ )
+    {
+     unsigned char k;
+     if ( cgmb_getb ( &k ) ) return 1;
+     s[i] = (char) k;
+    }
+
+  }
+ s[i] = '\0';
+
+ *str = (char*)strdup ( s );
+
+ free ( s );
+
+ return 0;
+}
+
+int cgmb_vdc ( double *vdc )
+{
+ signed char c;
+ short i;
+ long l;
+ float f;
+
+ if ( intcgm_cgm.vdc_type == 0 )
+  switch ( intcgm_cgm.vdc_int.b_prec )
+   {
+    case 0: if ( cgmb_geti8  ( &c ) ) return 1;
+            *vdc = (double) c;
+            break;
+    case 1: if ( cgmb_geti16 (  &i ) ) return 1;
+            *vdc = (double) i;
+            break;
+    case 2: if ( cgmb_geti24 ( &l ) ) return 1;
+            *vdc = (double) l;
+            break;
+    case 3: if ( cgmb_geti32 ( &l ) ) return 1;
+            *vdc = (double) l;
+            break;
+   }
+ else
+   switch ( intcgm_cgm.vdc_real.b_prec )
+    {
+     case 0: if ( cgmb_getfl32 ( &f ) ) return 1;
+             *vdc = (double) f;
+             break;
+     case 1: if ( cgmb_getfl64 ( vdc ) ) return 1;
+             break;
+     case 2: if ( cgmb_getfx32 ( &f ) ) return 1;
+             *vdc = (double) f;
+             break;
+     case 3: if ( cgmb_getfx64 ( vdc ) ) return 1;
+             break;
+    }
+
+ return 0;
+}
+
+int cgmb_p ( double *x, double *y )
+{
+ if ( cgmb_vdc ( x ) ) return 1;
+ if ( cgmb_vdc ( y ) ) return 1;
+ 
+ return 0;
+}
+
+int cgmb_co ( void *co )
+{
+ if ( intcgm_cgm.clrsm == 0 ) /* indexed */
+  {
+   unsigned long *ci = (unsigned long *) co;
+   if ( cgmb_ci ( ci ) ) return 1;
+  }
+ else
+  {
+   unsigned long *rgb = (unsigned long *) co;
+   if ( cgmb_rgb ( &rgb[0], &rgb[1], &rgb[2] ) ) return 1;
+  }
+
+ return 0;
+}
+
+int cgmb_pixeli ( unsigned long *ci, int localp )
+{
+ unsigned char c;
+ unsigned short i;
+
+ if ( localp==0 )
+  {
+   if ( intcgm_cgm.cix_prec==0 ) localp = 8;
+   else if ( intcgm_cgm.cix_prec==1 ) localp = 16;
+   else if ( intcgm_cgm.cix_prec==2 ) localp = 24;
+   else if ( intcgm_cgm.cix_prec==3 ) localp = 32;
+  }
+
+ switch ( localp )
+  {
+   case 1: if ( cgmb_getbit ( &c ) ) return 1;
+           *ci = (unsigned long) c;
+           break;
+   case 2: if ( cgmb_get2bit ( &c ) )
+           *ci = (unsigned long) c;
+           return 1;
+           break;
+   case 4: if ( cgmb_get4bit ( &c ) )
+           *ci = (unsigned long) c;
+           return 1;
+           break;
+   case 8: if ( cgmb_getu8  ( &c ) ) return 1; 
+           *ci = (unsigned long) c;
+           break;
+   case 16: if ( cgmb_getu16 ( &i ) ) return 1;
+           *ci = (unsigned long) i;
+           break;
+   case 24: if ( cgmb_getu24 ( ci ) ) return 1;
+           break;
+   case 32: if ( cgmb_getu32 ( ci ) ) return 1;
+           break;
+  }
+
+ return 0;
+}
+
+int cgmb_pixeld ( unsigned long *cd, int localp )
+{
+ unsigned char c;
+ unsigned short i;
+
+ if ( localp==0 )
+  {
+   if ( intcgm_cgm.cd_prec==0 ) localp = 8;
+   else if ( intcgm_cgm.cd_prec==1 ) localp = 16;
+   else if ( intcgm_cgm.cd_prec==2 ) localp = 24;
+   else if ( intcgm_cgm.cd_prec==3 ) localp = 32;
+  }
+
+ switch ( localp )
+  {
+   case  1: if ( cgmb_getbit  ( &c ) ) return 1;
+            *cd = (unsigned long) c;
+            break;
+   case  2: if ( cgmb_get2bit ( &c ) ) return 1;
+            *cd = (unsigned long) c;
+            break;
+   case  4: if ( cgmb_get4bit ( &c ) )
+            *cd = (unsigned long) c;
+            return 1;
+            break;
+   case  8: if ( cgmb_getu8  ( &c ) ) return 1;
+            *cd = (unsigned long) c;
+            break;
+   case 16: if ( cgmb_getu16 ( &i ) ) return 1;
+            *cd = (unsigned long) i;
+            break;
+   case 24: if ( cgmb_getu24 ( cd ) ) return 1;
+            break;
+   case 32: if ( cgmb_getu32 ( cd ) ) return 1;
+            break;
+  }
+
+ return 0;
+}
+
+int cgmb_pixelrgb ( unsigned long *r, unsigned long *g, unsigned long *b, int localp )
+{
+ if ( cgmb_pixeld ( r, localp ) ) return 1;
+ if ( cgmb_pixeld ( g, localp ) ) return 1;
+ if ( cgmb_pixeld ( b, localp ) ) return 1;
+
+ return 0;
+}
+
+int cgmb_getpixel ( void *co, int localp )
+{
+ if ( intcgm_cgm.clrsm == 0 ) /* indexed */
+  {
+   unsigned long *ci = (unsigned long *) co;
+   if ( cgmb_pixeli ( ci, localp ) ) return 1;
+  }
+ else
+  {
+   unsigned long *rgb = (unsigned long *) co;
+   if ( cgmb_pixelrgb ( &rgb[0], &rgb[1], &rgb[2], localp ) ) return 1;
+  }
+
+ return 0;
+}
+
+/************************************************
+*                                               *
+*            Funcoes para clear text            *
+*                                               *
+************************************************/
+
+void strlower ( char *string )
+{
+ int i;
+ for ( i=0; string[i]!='\0'; i++ )
+  string[i] = tolower ( string[i] );
+}
+
+char *cgmt_getsep (void)
+{
+ static char ch[256];
+
+ fscanf ( intcgm_cgm.fp, "%[ \r\n\t\v\f,]", ch );
+
+ return ch;
+}
+
+void cgmt_getcom (void)
+{
+ char chr[256], c;
+
+ while ( (c = fgetc( intcgm_cgm.fp )) == '%' )
+  {
+   fscanf ( intcgm_cgm.fp, "%[^%]%%", chr );
+
+   cgmt_getsep();
+  }
+
+ ungetc( c, intcgm_cgm.fp );
+}
+
+char *cgmt_getparentheses (void)
+{
+ static char ch[256];
+
+ cgmt_getsep();
+
+ fscanf ( intcgm_cgm.fp, "%[()]", ch );
+
+ return ch;
+}
+
+int cgmt_ter ( void )
+{
+ char c;
+
+ cgmt_getcom();
+
+ cgmt_getsep();
+
+ fscanf ( intcgm_cgm.fp, "%c", &c );
+
+ if ( c=='/' || c==';' ) return 0;
+
+ ungetc ( c, intcgm_cgm.fp );
+
+ return 1;
+}
+
+int cgmt_rch ( void )
+{
+ char chr[256];
+ char *pt;
+ int i, j;
+
+ cgmt_getsep();
+
+ cgmt_getcom();
+
+/* addcounter();*/
+
+ fscanf ( intcgm_cgm.fp, "%[^ \r\n\t\v\f,/;%\"()]", chr );
+
+ pt = strtok(chr,"_$");
+
+ while ( (pt = strtok ( NULL, "_$" )) )
+  strcat ( chr, pt );
+
+ strlower(chr);
+
+ for ( i=0; _cgmt_comandos[i]!=NULL; i++ )
+  {
+   for ( j=0; _cgmt_comandos[i][j]!=NULL; j++ )
+    {
+     if ( strcmp( chr, _cgmt_comandos[i][j]->nome )==0 )
+      {
+       int r = (*_cgmt_comandos[i][j]->func)();
+	   cgm_getfilepos ();
+	   return r;
+	  }
+    }
+  }
+
+
+ return 0;
+}
+
+int cgmt_i ( long *i )
+{
+ cgmt_getsep();
+
+ cgmt_getcom();
+
+ if ( fscanf( intcgm_cgm.fp, "%ld", i ) ) return 0;
+
+ return 1;
+}
+
+int cgmt_ci ( unsigned long *ci )
+{
+ return cgmt_i ( (long*)ci );
+}
+
+int cgmt_cd ( unsigned long *cd )
+{
+ return cgmt_i ( (long *) cd );
+}
+
+int cgmt_rgb ( unsigned long *r, unsigned long *g, unsigned long *b )
+{
+ if ( cgmt_cd ( r ) ) return 1;
+
+ if ( cgmt_cd ( g ) ) return 1;
+
+ if ( cgmt_cd ( b ) ) return 1;
+ 
+ return 0;
+}
+
+int cgmt_ix ( long *ix )
+{
+ return cgmt_i ( (long *) ix );
+}
+
+int cgmt_e ( short *e, const char **el )
+{
+ char chr[256];
+ int i;
+ char *pt;
+
+ cgmt_getsep();
+
+ cgmt_getcom();
+
+ fscanf ( intcgm_cgm.fp, "%[^ \r\n\t\v\f,/;%\"\']", chr );
+
+ strlower(chr);
+
+ pt = strtok(chr,"_$");
+
+ while ( (pt = strtok ( NULL, "_$" )) )
+  strcat ( chr, pt );
+
+ for ( i=0; el[i]!=NULL; i++ )
+  if ( strcmp( chr, el[i] ) == 0 )
+   {
+    *e = i;
+    return 0;
+   };
+   
+ return 1;
+}
+
+int cgmt_r ( double *f )
+{
+ cgmt_getsep();
+
+ cgmt_getcom();
+
+ if ( fscanf( intcgm_cgm.fp, "%lg", f ) ) return 0;
+
+ return 1;
+}
+
+int cgmt_s ( char **str )
+{
+ char c, delim;
+ int intcgm_block = 80;
+ int i = 0;
+
+ *str = (char *) malloc ( intcgm_block*sizeof(char) );
+
+ strcpy ( *str, "" );
+
+ cgmt_getsep();
+
+ cgmt_getcom();
+
+ delim = fgetc ( intcgm_cgm.fp );
+
+ if ( delim != '"' && delim != '\'' ) return 1;
+
+ do
+  {
+   if ( (c=fgetc(intcgm_cgm.fp))==delim )
+    if ( (c=fgetc(intcgm_cgm.fp))==delim )
+     (*str)[i++] = c;
+    else 
+     {
+      ungetc(c,intcgm_cgm.fp);
+      break;
+     }
+   else
+    (*str)[i++] = c;
+
+   if ( (i+1)==intcgm_block )
+    {
+     intcgm_block *= 2;
+
+     *str = (char *) realloc ( *str, intcgm_block*sizeof(char) );
+    }
+  } while ( 1 );
+
+ (*str)[i] = '\0';
+
+ /* addcounter();*/
+
+ return 0;
+}
+
+int cgmt_vdc ( double *vdc )
+{
+ long l;
+
+ if ( intcgm_cgm.vdc_type==0 )
+  {
+   if ( cgmt_i ( &l ) ) return 1;
+   *vdc = (double) l;
+   return 0;
+  }
+ else
+  return cgmt_r ( vdc  );
+}
+
+int cgmt_p ( double *x, double *y )
+{
+ cgmt_getparentheses();
+
+ if ( cgmt_vdc ( x ) ) return 1;
+
+ if ( cgmt_vdc ( y ) ) return 1;
+
+ cgmt_getparentheses();
+
+ return 0;
+}
+
+int cgmt_co ( void *co )
+{
+ if ( intcgm_cgm.clrsm == 0 ) /* indexed */
+  {
+   unsigned long *ci = (unsigned long*)co;
+   if ( cgmt_ci ( ci ) ) return 1;
+  }
+ else
+  {
+   unsigned long *cb = (unsigned long *) co;
+   if ( cgmt_rgb ( &cb[0], &cb[1], &cb[2] ) ) return 1;
+  }
+  
+ return 0; 
+}
diff --git a/src/intcgm/intcgm2.h b/src/intcgm/intcgm2.h
new file mode 100644
index 0000000..d7f5204
--- /dev/null
+++ b/src/intcgm/intcgm2.h
@@ -0,0 +1,52 @@
+
+int cgm_getfilepos ( void );
+
+int cgmb_exec_comand ( int, int );
+int cgmb_geti8  ( signed char * );
+int cgmb_geti16 ( short * );
+int cgmb_geti24 ( long * );
+int cgmb_geti32 ( long * );
+int cgmb_getu8  ( unsigned char * );
+int cgmb_getu16 ( unsigned short * );
+int cgmb_getu24 ( unsigned long * );
+int cgmb_getu32 ( unsigned long * );
+int cgmb_getfl32 ( float * );
+int cgmb_getfl64 ( double * );
+int cgmb_getfx32 ( float * );
+int cgmb_getfx64 ( double * );
+int cgmb_ter ( void );
+int cgmb_rch ( void );
+int cgmb_ci ( unsigned long * );
+int cgmb_cd ( unsigned long * );
+int cgmb_rgb ( unsigned long *, unsigned long *, unsigned long * );
+int cgmb_ix ( long * );
+int cgmb_e ( short * );
+int cgmb_i ( long * );
+int cgmb_u ( unsigned long * );
+int cgmb_r ( double * );
+int cgmb_s ( char ** );
+int cgmb_vdc ( double * );
+int cgmb_p ( double *, double * );
+int cgmb_co ( void * );
+int cgmb_getpixel ( void *, int );
+int cgmb_getc ( unsigned char * );
+
+char *cgmt_getsep ( void );
+void cgmt_getcom ( void );
+char *cgmt_getparentheses ( void );
+int cgmt_ter ( void );
+int cgmt_rch ( void );
+int cgmt_i ( long * );
+int cgmt_ci ( unsigned long * );
+int cgmt_cd ( unsigned long * );
+int cgmt_rgb ( unsigned long *, unsigned long *, unsigned long * );
+int cgmt_ix ( long * );
+int cgmt_e ( short *, const char ** );
+int cgmt_r ( double * );
+int cgmt_s ( char ** );
+int cgmt_vdc ( double * );
+int cgmt_p ( double *, double * );
+int cgmt_co ( void * );
+
+
+
diff --git a/src/intcgm/intcgm4.c b/src/intcgm/intcgm4.c
new file mode 100644
index 0000000..4c8afe0
--- /dev/null
+++ b/src/intcgm/intcgm4.c
@@ -0,0 +1,1265 @@
+#define _INTCGM4_C_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+
+#include <cd.h>
+#include <cdcgm.h>
+
+#include "list.h"
+#include "types.h"
+#include "intcgm.h"
+#include "intcgm2.h"
+#include "intcgm4.h"
+#include "intcgm6.h"
+#include "ellipse.h"
+#include "circle.h"
+#include "sism.h"
+
+#ifndef PI
+#define PI 3.1415931
+#endif
+#define TWOPI 2*PI
+
+static double myhypot ( double x, double y )
+{
+ return sqrt ( x*x + y*y );
+}
+
+int cgm_do_vdcext ( tpoint first, tpoint second )
+{
+ double width, height;
+ double tmp;
+ double razao_vp;
+ double razao_wn;
+ int w_pixel, h_pixel;
+ double w_mm, h_mm;
+
+ if ( first.x > second.x )
+  {
+   tmp = first.x;
+   first.x = second.x;
+   second.x = tmp;
+  }
+
+ if ( first.y > second.y )
+  {
+   tmp = first.y;
+   first.y = second.y;
+   second.y = tmp;
+  }
+
+ width = intcgm_view_xmax-intcgm_view_xmin+1;
+ height = intcgm_view_ymax-intcgm_view_ymin+1;
+
+ razao_vp = (double) width/ (double) height;
+ razao_wn = (second.x-first.x) / (second.y-first.y);
+
+ if ( razao_vp > razao_wn )
+  {
+   first.x -= ((second.y-first.y)*razao_vp - (second.x-first.x)) / 2.;
+   second.x = (second.y-first.y)*razao_vp+first.x;
+  }
+ else
+  {
+   first.y -= ((second.x-first.x)/razao_vp - (second.y-first.y)) / 2.;
+   second.y = (second.x-first.x)/razao_vp+first.y;
+  }
+
+ intcgm_vdc_ext.xmin = first.x;
+ intcgm_vdc_ext.xmax = second.x;
+ intcgm_vdc_ext.ymin = first.y;
+ intcgm_vdc_ext.ymax = second.y;
+
+ intcgm_scale_factor_x = width/(second.x-first.x);
+ intcgm_scale_factor_y = height/(second.y-first.y);
+ intcgm_scale_factor   = sqrt(width * width + height * height)/sqrt((second.x-first.x)+(second.y-first.y));
+ cdCanvasGetSize (intcgm_canvas,  &w_pixel, &h_pixel, &w_mm, &h_mm );
+ intcgm_scale_factor_mm_x = w_pixel/w_mm;
+ intcgm_scale_factor_mm_y = h_pixel/h_mm;
+
+ if ( intcgm_cgm.drawing_mode==ABSTRACT )
+  {
+   intcgm_clip_xmin = cgm_canvas2vdcx ( intcgm_view_xmin );
+   intcgm_clip_xmax = cgm_canvas2vdcx ( intcgm_view_xmax );
+   intcgm_clip_ymin = cgm_canvas2vdcy ( intcgm_view_ymin );
+   intcgm_clip_ymax = cgm_canvas2vdcy ( intcgm_view_ymax );
+  }
+ else
+  {
+   intcgm_clip_xmin = intcgm_vdc_ext.xmin*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_xmax = intcgm_vdc_ext.xmax*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_ymin = intcgm_vdc_ext.ymin*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_ymax = intcgm_vdc_ext.ymax*intcgm_cgm.scaling_mode.scale_factor;
+  }
+
+ cdCanvasClipArea (intcgm_canvas, cgm_vdcx2canvas(first.x), cgm_vdcx2canvas(second.x),
+              cgm_vdcy2canvas(first.y), cgm_vdcy2canvas(second.y) );
+ cdCanvasClip(intcgm_canvas,  CD_CLIPOFF );
+
+ return 0;
+}
+
+int cgm_do_bckcol ( trgb rgb )
+{
+ long int cor = cdEncodeColor ( (unsigned char) rgb.red,
+                                (unsigned char) rgb.green,
+                                (unsigned char) rgb.blue );
+
+ cdCanvasSetBackground (intcgm_canvas, cor );
+
+ return 0;
+}
+
+int cgm_do_transp ( int transparency )
+{
+ if ( transparency )
+  cdCanvasBackOpacity (intcgm_canvas,  CD_TRANSPARENT );
+ else
+  cdCanvasBackOpacity (intcgm_canvas,  CD_OPAQUE );
+
+ return 0;
+}
+
+int cgm_do_clprec ( tpoint first, tpoint second )
+{
+ double tmp;
+
+ if ( first.x > second.x )
+  {
+   tmp = first.x;
+   first.x = second.x;
+   second.x = tmp;
+  }
+
+ if ( first.y > second.y )
+  {
+   tmp = first.y;
+   first.y = second.y;
+   second.y = tmp;
+  }
+
+ cdCanvasClipArea (intcgm_canvas,  cgm_vdcx2canvas(first.x), cgm_vdcx2canvas(second.x),
+              cgm_vdcy2canvas(first.y), cgm_vdcy2canvas(second.y) );
+
+ return 0;
+}
+
+int cgm_do_clpind ( int indicator )
+{
+ if ( indicator )
+  cdCanvasClip(intcgm_canvas,  CD_CLIPAREA );
+ else
+  cdCanvasClip(intcgm_canvas,  CD_CLIPOFF );
+
+ return 0;
+}
+
+int cgm_do_polyln ( int n_points, tpoint *pt )
+{
+ int i;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_setlinestyle ( intcgm_line_att.type );
+ cgm_setlinewidth ( intcgm_line_att.width );
+ cor = cgm_getcolor ( intcgm_line_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cdCanvasBegin(intcgm_canvas,  CD_OPEN_LINES );
+
+ for ( i=0; i<n_points; i++ )
+   cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y) );
+
+ cdCanvasEnd (intcgm_canvas);
+
+ return 0;
+}
+
+int cgm_do_incply ( int n_points, tpoint *pt )
+{
+ int i;
+ double x, y;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getincpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_setlinestyle ( intcgm_line_att.type );
+ cgm_setlinewidth ( intcgm_line_att.width );
+ cor = cgm_getcolor ( intcgm_line_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cdCanvasBegin(intcgm_canvas,  CD_OPEN_LINES );
+
+ x = pt[0].x;    y = pt[0].y;
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[0].x), cgm_vdcy2canvas(pt[0].y) );
+
+ for ( i=1; i<n_points; i++ )
+   {
+    x += pt[i].x;      y += pt[i].x;
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(x), cgm_vdcy2canvas(y) );
+   }
+
+ cdCanvasEnd (intcgm_canvas);
+
+ return 0;
+}
+
+int cgm_do_djtply ( int n_points, tpoint *pt )
+{
+ int i;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ if ( n_points < 2 ) return 1;
+
+ cgm_setlinestyle ( intcgm_line_att.type );
+ cgm_setlinewidth ( intcgm_line_att.width );
+ cor = cgm_getcolor ( intcgm_line_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ for ( i=0; i<n_points; i=i+2 )
+   cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y), 
+            cgm_vdcx2canvas(pt[i+1].x), cgm_vdcy2canvas(pt[i+1].y) );
+
+ return 0;
+}
+
+int cgm_do_indpl ( int n_points, tpoint *pt )
+{
+ int i;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getincpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ if ( n_points < 2 ) return 1;
+
+ cgm_setlinestyle ( intcgm_line_att.type );
+ cgm_setlinewidth ( intcgm_line_att.width );
+ cor = cgm_getcolor ( intcgm_line_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ pt[1].x = pt[0].x + pt[1].x;    pt[1].y = pt[0].y + pt[1].y;
+ cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(pt[0].x), cgm_vdcy2canvas(pt[0].y), 
+          cgm_vdcx2canvas(pt[1].x), cgm_vdcy2canvas(pt[1].y) );
+
+ for ( i=2; i<n_points; i=i+2 )
+   {
+    pt[i].x += pt[i-1].x;    pt[i].y += pt[i-1].y;
+    pt[i+1].x += pt[i].x;    pt[i+1].y += pt[i].y;
+    cdCanvasLine (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y),
+             cgm_vdcx2canvas(pt[i+1].x), cgm_vdcy2canvas(pt[i+1].y) );
+   }
+
+ return 0;
+}
+
+int cgm_do_polymk ( int n_points, tpoint *pt )
+{
+ int i;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_setmarktype ( intcgm_marker_att.type );
+ cgm_setmarksize ( intcgm_marker_att.size );
+ cor = cgm_getcolor ( intcgm_marker_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ for ( i=0; i<n_points; i++ )
+   cdCanvasMark (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y) );
+
+ return 0;
+}
+
+int cgm_do_incplm ( int n_points, tpoint *pt )
+{
+ int i;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getincpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_setmarktype ( intcgm_marker_att.type );
+ cgm_setmarksize ( intcgm_marker_att.size );
+ cor = cgm_getcolor ( intcgm_marker_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cdCanvasMark (intcgm_canvas,  cgm_vdcx2canvas(pt[0].x), cgm_vdcy2canvas(pt[0].y) );
+
+ for ( i=1; i<n_points; i++ )
+   {
+    pt[i].x += pt[i-1].x;   pt[i].y += pt[i-1].y;
+    cdCanvasMark (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y) );
+   }
+
+ return 0;
+}
+
+int cgm_do_text ( int mode, char *string, tpoint pos )
+{
+ long int cor;
+
+ cor = cgm_getcolor ( intcgm_text_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cgm_setfont ( intcgm_text_att.font, intcgm_text_att.style, intcgm_text_att.height );
+
+ cdCanvasText (intcgm_canvas,  cgm_vdcx2canvas(pos.x), cgm_vdcy2canvas(pos.y), string );
+
+ return 0;
+}
+
+int cgm_do_txtalign ( int hor, int ver )
+{
+ enum { NORMHORIZ, LEFT, CTR, RIGHT };
+ enum { NORMVERT, TOP, CAP, HALF, BASE, BOTTOM };
+
+ switch (hor)
+  {
+   case NORMHORIZ:
+    switch (ver)
+     {
+      case NORMVERT:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_CENTER);
+       break;
+      case TOP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH);
+       break;
+      case CAP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH);
+       break;
+      case HALF:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_CENTER);
+       break;
+      case BASE:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH);
+       break;
+      case BOTTOM:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH);
+       break;
+     }
+    break;
+   case LEFT:
+    switch (ver)
+     {
+      case NORMVERT:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_WEST);
+       break;
+      case TOP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH_WEST);
+       break;
+      case CAP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH_WEST);
+       break;
+      case HALF:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_WEST);
+       break;
+      case BASE:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH_WEST);
+       break;
+      case BOTTOM:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH_WEST);
+       break;
+     }
+    break;
+   case CTR:
+    switch (ver)
+     {
+      case NORMVERT:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_CENTER);
+       break;
+      case TOP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH);
+       break;
+      case CAP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH);
+       break;
+      case HALF:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_CENTER);
+       break;
+      case BASE:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH);
+       break;
+      case BOTTOM:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH);
+       break;
+     }
+    break;
+   case RIGHT:
+    switch (ver)
+     {
+      case NORMVERT:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_EAST);
+       break;
+      case TOP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH_EAST);
+       break;
+      case CAP:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_NORTH_EAST);
+       break;
+      case HALF:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_EAST);
+       break;
+      case BASE:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH_EAST);
+       break;
+      case BOTTOM:
+	   cdCanvasTextAlignment(intcgm_canvas, CD_SOUTH_EAST);
+       break;
+     }
+    break;
+  }
+
+ return 0;
+}
+
+int cgm_do_polygn ( int n_points, tpoint *pt )
+{
+ int i;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cor = cgm_getcolor ( intcgm_fill_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cgm_setlinewidth ( intcgm_line_att.width );
+
+ if ( intcgm_fill_att.int_style!=HOLLOW && intcgm_fill_att.int_style!=EMPTY )
+  {
+   cdCanvasBegin(intcgm_canvas,  cgm_setintstyle ( intcgm_fill_att.int_style )  );
+
+   for ( i=0; i<n_points; i++ )
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y) );
+ 
+    cdCanvasEnd (intcgm_canvas);
+  }
+
+ if ( intcgm_edge_att.visibility==ON )
+  {
+   cor = cgm_getcolor ( intcgm_edge_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinewidth ( intcgm_edge_att.width );
+
+   cdCanvasBegin(intcgm_canvas,  CD_CLOSED_LINES  );
+
+   for ( i=0; i<n_points; i++ )
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y) );
+
+   cdCanvasEnd (intcgm_canvas);
+  }
+
+ return 0;
+}
+
+int cgm_do_incplg ( int n_points, tpoint *pt )
+{
+ int i;
+ tpoint p;
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getincpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+                    
+ cor = cgm_getcolor ( intcgm_fill_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cdCanvasBegin(intcgm_canvas,  cgm_setintstyle ( intcgm_fill_att.int_style ) );
+
+ p.x = pt[0].x;    p.y = pt[0].y;
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[0].x), cgm_vdcy2canvas(pt[0].y) );
+
+ for ( i=1; i<n_points; i++ )
+  {
+   p.x += pt[i].x;      p.y += pt[i].y;
+   cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(p.x), cgm_vdcy2canvas(p.y) );
+  }
+
+ cdCanvasEnd (intcgm_canvas);
+
+ return 0;
+}
+
+int cgm_do_plgset( int incremental, int n_points, tpoint *pt, short *flag )
+{
+ int i, j;
+ tpoint closure;
+ long int cor;
+ int start;
+ int vis = intcgm_edge_att.visibility;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cgm_getpolybbox ( pt, n_points, &bb_xmin, &bb_ymin, &bb_xmax, &bb_ymax );
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ intcgm_edge_att.visibility = OFF;
+
+ cor = cgm_getcolor ( intcgm_fill_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ if ( intcgm_fill_att.int_style!=HOLLOW && intcgm_fill_att.int_style!=EMPTY )
+  {
+   cdCanvasBegin(intcgm_canvas,  cgm_setintstyle ( intcgm_fill_att.int_style )  );
+   start = 1;
+   for ( i=0; i<n_points; i++ )
+    {
+     if ( start )
+      {
+       closure.x = pt[i].x;
+       closure.y = pt[i].y;
+       start = 0;
+	    }
+     else if ( incremental==YES )
+      {
+       pt[i].x = pt[i].x+pt[i-1].x;
+       pt[i].y = pt[i].y+pt[i-1].y;
+      }
+
+     if ( flag[i]==CLOSE_VISIBLE ||	flag[i]==CLOSE_INVISIBLE )
+      {
+       cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y) );
+       cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(closure.x), cgm_vdcy2canvas(closure.y) );
+	     start=1;
+      }
+	 else
+      cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[i].x), cgm_vdcy2canvas(pt[i].y) );
+	}
+   cdCanvasEnd (intcgm_canvas);
+  }
+
+
+ intcgm_edge_att.visibility = vis;
+
+ if ( intcgm_edge_att.visibility==ON )
+  {
+   int np;
+
+   cor = cgm_getcolor ( intcgm_edge_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinewidth ( intcgm_edge_att.width );
+
+   np = 0;
+   start = 0;
+   for ( i=0; i<n_points; i++ )
+    {
+     if ( incremental==YES )
+      {
+       pt[i].x = pt[i].x+pt[i-1].x;
+       pt[i].y = pt[i].y+pt[i-1].y;
+      }
+
+     if ( flag[i]==CLOSE_VISIBLE || (flag[i]==VISIBLE && i==n_points-1) )
+      {
+       cdCanvasBegin(intcgm_canvas,  CD_CLOSED_LINES );
+       for ( j=0; j<np; j++ )
+        cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[start+j].x), cgm_vdcy2canvas(pt[start+j].y) );
+       cdCanvasEnd(intcgm_canvas);
+	     start += np;
+       np = 0;
+      }
+     else if ( flag[i]==INVISIBLE || flag[i]==CLOSE_INVISIBLE )
+      {
+       cdCanvasBegin(intcgm_canvas,  CD_OPEN_LINES );
+       for ( j=0; j<np; j++ )
+        cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(pt[start+j].x), cgm_vdcy2canvas(pt[start+j].y) );
+       cdCanvasEnd(intcgm_canvas);
+	     start += np;
+       np = 0;
+      }
+     else
+      np++;
+    }
+  }
+
+ return 0;
+}
+
+int cgm_do_cellar ( tpoint corner1, tpoint corner2, tpoint corner3, int nx,
+                 int ny, long color_prec, tcolor *cell )
+{
+ int cx1, cy1, cx2, cy2, cx3, cy3, tmp, i, j;
+ unsigned char *r, *g, *b;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = ( corner1.x < corner2.x ) ? corner1.x : corner2.x;
+ bb_xmax = ( corner1.x > corner2.x ) ? corner1.x : corner2.x;
+ bb_ymin = ( corner1.y < corner2.y ) ? corner1.y : corner2.y;
+ bb_ymax = ( corner1.y > corner2.y ) ? corner1.y : corner2.y;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ r = (unsigned char *) malloc ( nx*ny*sizeof(unsigned char) );
+ g = (unsigned char *) malloc ( nx*ny*sizeof(unsigned char) );
+ b = (unsigned char *) malloc ( nx*ny*sizeof(unsigned char) );
+ 
+ cx1 = cgm_vdcx2canvas(corner1.x);
+ cy1 = cgm_vdcy2canvas(corner1.y);
+ cx2 = cgm_vdcx2canvas(corner2.x);
+ cy2 = cgm_vdcy2canvas(corner2.y);
+ cx3 = cgm_vdcx2canvas(corner3.x);
+ cy3 = cgm_vdcy2canvas(corner3.y);
+
+#if 1
+ if ( cx1<cx3 && cy1==cy3 && cx2==cx3 && cy2>cy3 )
+  {
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[nx*i+j].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[nx*i+j].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[nx*i+j].rgb.blue;
+    }
+  }
+ else if ( cx1==cx3 && cy1<cy3 && cx2>cx3 && cy2==cy3 )
+  {
+   tmp = nx;   nx = ny;    ny = tmp;
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[ny*j+i].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[ny*j+i].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[ny*j+i].rgb.blue;
+    }
+  }
+ else if ( cx1<cx3 && cy1==cy3 && cx2==cx3 && cy2<cy3 )
+  {
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[nx*(ny-i-1)+j].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[nx*(ny-i-1)+j].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[nx*(ny-i-1)+j].rgb.blue;
+    }
+  }
+ else if ( cx1==cx3 && cy1>cy3 && cx2>cx3 && cy2==cy3 )
+  {
+   tmp = nx;   nx = ny;    ny = tmp;
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[ny*j+(ny-i-1)].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[ny*j+(ny-i-1)].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[ny*j+(ny-i-1)].rgb.blue;
+    }
+  }
+ else if ( cx1>cx3 && cy1==cy3 && cx2==cx3 && cy2>cy3 )
+  {
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[nx*i+(nx-j-1)].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[nx*i+(nx-j-1)].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[nx*i+(nx-j-1)].rgb.blue;
+    }
+  }
+ else if ( cx1==cx3 && cy1>cy3 && cx2<cx3 && cy2==cy3 )
+  {
+   tmp = nx;   nx = ny;    ny = tmp;
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[ny*(nx-j-1)+(ny-i-1)].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[ny*(nx-j-1)+(ny-i-1)].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[ny*(nx-j-1)+(ny-i-1)].rgb.blue;
+    }
+  }
+ else if ( cx1>cx3 && cy1==cy3 && cx2==cx3 && cy2<cy3 )
+  {
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[nx*(ny-i-1)+(nx-j-1)].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[nx*(ny-i-1)+(nx-j-1)].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[nx*(ny-i-1)+(nx-j-1)].rgb.blue;
+    }
+  }
+ else if ( cx1==cx3 && cy1<cy3 && cx2<cx3 && cy2==cy3 )
+  {
+   tmp = nx;   nx = ny;    ny = tmp;
+   for ( i=0; i<ny; i++ )
+    for ( j=0; j<nx; j++ )
+    {
+     r[nx*i+j] = (unsigned char) cell[ny*(nx-j-1)+i].rgb.red;
+     g[nx*i+j] = (unsigned char) cell[ny*(nx-j-1)+i].rgb.green;
+     b[nx*i+j] = (unsigned char) cell[ny*(nx-j-1)+i].rgb.blue;
+    }
+  }
+#else
+ for ( i=0; i<nx; i++ )
+  for ( j=0; j<ny; j++ )
+   {
+    r[nx*j+i] = (unsigned char) cell[nx*j+i].rgb.red;
+    g[nx*j+i] = (unsigned char) cell[nx*j+i].rgb.green;
+    b[nx*j+i] = (unsigned char) cell[nx*j+i].rgb.blue;
+   }
+#endif
+
+#if 1
+ if ( cx1>cx2 )
+  {
+   tmp = cx1;
+   cx1 = cx2;
+   cx2 = tmp;
+  }
+
+ if ( cy1>cy2 )
+  {
+   tmp = cy1;
+   cy1 = cy2;
+   cy2 = tmp;
+  }
+#endif
+
+ cdCanvasPutImageRectRGB (intcgm_canvas, nx, ny, r, g, b, cx1, cy1, cx2-cx1+1, cy2-cy1+1,0,0,0,0 );
+
+ free(r);
+ free(g);
+ free(b);
+
+ return 0;
+}
+
+int cgm_do_gdp ( int identifier, tpoint *pt, char *data_rec )
+{
+ if ( identifier==-4 )
+  cgm_sism4 ( pt, data_rec );
+ else if ( identifier==-5 )
+  cgm_sism5 ( data_rec );
+
+ return 0;
+}
+
+int cgm_do_rect ( tpoint point1, tpoint point2 )
+{
+ long int cor;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = ( point1.x < point2.x ) ? point1.x : point2.x;
+ bb_xmax = ( point1.x > point2.x ) ? point1.x : point2.x;
+ bb_ymin = ( point1.y < point2.y ) ? point1.y : point2.y;
+ bb_ymax = ( point1.y > point2.y ) ? point1.y : point2.y;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cor = cgm_getcolor ( intcgm_fill_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cdCanvasBegin(intcgm_canvas,  cgm_setintstyle ( intcgm_fill_att.int_style ) );
+
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(point1.x), cgm_vdcy2canvas(point1.y) );
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(point2.x), cgm_vdcy2canvas(point1.y) );
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(point2.x), cgm_vdcy2canvas(point2.y) );
+ cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(point1.x), cgm_vdcy2canvas(point2.y) );
+
+ cdCanvasEnd (intcgm_canvas);
+
+ return 0;
+}
+
+int cgm_do_circle ( tpoint center, double radius )
+{
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = center.x - radius;
+ bb_xmax = center.x + radius;
+ bb_ymin = center.y - radius;
+ bb_ymax = center.y + radius;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ if ( intcgm_fill_att.int_style!=EMPTY )
+  {
+   long int cor;
+
+   cor = cgm_getcolor ( intcgm_fill_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinestyle ( intcgm_line_att.type );
+   cgm_setlinewidth ( intcgm_line_att.width );
+
+   if ( intcgm_fill_att.int_style!=EMPTY )
+    cgm_poly_circle ( center.x, center.y, radius, 0, TWOPI, CLOSED_CHORD );
+   else
+    cgm_line_circle ( center.x, center.y, radius, 0, TWOPI, CLOSED_CHORD );
+  }
+
+ if ( intcgm_edge_att.visibility==ON )
+  {
+   long int cor;
+
+   cor = cgm_getcolor ( intcgm_edge_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinestyle ( intcgm_edge_att.type );
+   cgm_setlinewidth ( intcgm_edge_att.width );
+
+   cgm_line_circle ( center.x, center.y, radius, 0., TWOPI, CLOSED_CHORD );
+  }
+
+ return 0;
+}
+
+static double angulo ( double cx, double cy, double px, double py )
+{
+ double ang;
+ if ((fabs(py-cy)<1e-9) && (fabs(px-cx)<1e-9))
+   ang = 0.0;
+ else
+   ang = atan2 ( py - cy , px - cx );
+
+ if ( ang<0.) ang = TWOPI - fabs(ang); 
+
+ return ang;
+}
+
+static void solve2 ( double m[][2], double *b, double *x )
+{
+ double det;
+
+ det = m[0][0]*m[1][1] - m[0][1]*m[1][0];
+
+ if ( det==0.0 ) return;
+
+ x[0] = ( b[0]*m[1][1] - b[1]*m[1][0] ) / det;
+ x[1] = ( m[0][0]*b[1] - m[0][1]*b[0] ) / det;
+}
+
+static void getcenter ( double xs, double ys, double xi, double yi, double xe, double ye,
+                        double *xc, double *yc )
+{
+ double c[2];
+
+ double x2, y2, x3, y3, m[2][2], b[2];
+
+ x2 = xi - xs;
+ y2 = yi - ys;
+ x3 = xe - xs;
+ y3 = ye - ys;
+
+ m[0][0] = 2*x2;
+ m[1][0] = 2*y2;
+ m[0][1] = 2*x3;
+ m[1][1] = 2*y3;
+ b[0]    = x2*x2 + y2*y2;
+ b[1]    = x3*x3 + y3*y3;
+
+ solve2 ( m, b, c );
+
+ *xc = c[0] + xs;
+ *yc = c[1] + ys;
+}
+
+int cgm_do_circ3p ( tpoint starting, tpoint intermediate, tpoint ending )
+{
+ long int cor;
+ double xc, yc;
+ double angi, angm, angf;
+ double radius;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cor = cgm_getcolor ( intcgm_line_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cgm_setlinestyle ( intcgm_line_att.type );
+ cgm_setlinewidth ( intcgm_line_att.width );
+
+ getcenter ( starting.x, starting.y, intermediate.x, intermediate.y, ending.x, ending.y, &xc, &yc );
+
+ angi = angulo( xc, yc, starting.x, starting.y );
+ angm = angulo( xc, yc, intermediate.x, intermediate.y );
+ angf = angulo( xc, yc, ending.x, ending.y );
+
+ if ( angm<angi )
+  {
+   double tmp = angi;
+   angi = angf;
+   angf = tmp;
+  } 
+
+ if ( angf<angi ) angf = angf + TWOPI;
+
+ radius = sqrt ( (starting.x-xc)*(starting.x-xc) + (starting.y-yc)*(starting.y-yc) );
+
+ bb_xmin = xc - radius;
+ bb_xmax = xc + radius;
+ bb_ymin = yc - radius;
+ bb_ymax = yc + radius;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_line_circle ( xc, yc, radius, angi, angf, OPEN );
+
+ return 0;
+}
+
+int cgm_do_circ3pc ( tpoint starting, tpoint intermediate, tpoint ending, int close_type )
+{
+ long int cor;
+ double xc, yc;
+ double angi, angm, angf;
+ double radius;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ cor = cgm_getcolor ( intcgm_fill_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cgm_setlinestyle ( intcgm_line_att.type );
+ cgm_setlinewidth ( intcgm_line_att.width );
+
+ getcenter ( starting.x, starting.y, intermediate.x, intermediate.y, ending.x, ending.y, &xc, &yc );
+
+ angi = angulo( xc, yc, starting.x, starting.y );
+ angm = angulo( xc, yc, intermediate.x, intermediate.y );
+ angf = angulo( xc, yc, ending.x, ending.y );
+
+ radius = sqrt ( (starting.x-xc)*(starting.x-xc) + (starting.y-yc)*(starting.y-yc) );
+
+ bb_xmin = xc - radius;
+ bb_xmax = xc + radius;
+ bb_ymin = yc - radius;
+ bb_ymax = yc + radius;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ if ( angm<angi )
+  {
+   double tmp = angi;
+   angi = angf;
+   angf = tmp;
+  } 
+
+ if ( angf<angi ) angf = angf + TWOPI;
+
+ if ( intcgm_fill_att.int_style!=EMPTY )
+  {
+   long int cor;
+
+   cor = cgm_getcolor ( intcgm_fill_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinewidth ( intcgm_line_att.width );
+
+   if ( intcgm_fill_att.int_style!=EMPTY )
+    cgm_poly_circle ( xc, yc, radius, angi, angf, (close_type) ? CLOSED_CHORD : CLOSED_PIE );
+   else
+    cgm_line_circle ( xc, yc, radius, angi, angf, (close_type) ? CLOSED_CHORD : CLOSED_PIE );
+  }
+
+ if ( intcgm_edge_att.visibility==ON )
+  {
+   long int cor;
+
+   cor = cgm_getcolor ( intcgm_edge_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinestyle ( intcgm_edge_att.type );
+   cgm_setlinewidth ( intcgm_edge_att.width );
+
+   cgm_line_circle ( xc, yc, radius, angi, angf, (close_type) ? CLOSED_CHORD : CLOSED_PIE );
+  }
+
+ return 0;
+}
+
+int cgm_do_circcnt ( tpoint center, tpoint start, tpoint end, double radius )
+{
+ long int cor;
+ double angi, angf;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = center.x - radius;
+ bb_xmax = center.x + radius;
+ bb_ymin = center.y - radius;
+ bb_ymax = center.y + radius;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cor = cgm_getcolor ( intcgm_fill_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cgm_setlinewidth ( intcgm_line_att.width );
+
+ angi = angulo( center.x, center.y, start.x, start.y );
+ angf = angulo( center.x, center.y, end.x, end.y );
+
+ if ( angf<angi )
+  {
+   double tmp = angi;
+   angi = angf;
+   angf = tmp;
+  } 
+
+ cgm_line_circle ( center.x, center.y, radius, angi, angf, OPEN );
+
+ return 0;
+}
+
+int cgm_do_ccntcl ( tpoint center, tpoint start, tpoint end, double radius, int close_type )
+{
+ long int cor;
+ double angi, angf;
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = center.x - radius;
+ bb_xmax = center.x + radius;
+ bb_ymin = center.y - radius;
+ bb_ymax = center.y + radius;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cor = cgm_getcolor ( intcgm_fill_att.color );
+ cdCanvasSetForeground (intcgm_canvas,  cor );
+
+ cgm_setlinewidth ( intcgm_line_att.width );
+
+ angi = angulo( center.x, center.y, start.x, start.y );
+ angf = angulo( center.x, center.y, end.x, end.y );
+
+ if ( angf<angi )
+  {
+   double tmp = angi;
+   angi = angf;
+   angf = tmp;
+  } 
+
+ if ( intcgm_fill_att.int_style!=HOLLOW && intcgm_fill_att.int_style!=EMPTY )
+  {
+   long int cor;
+
+   cor = cgm_getcolor ( intcgm_fill_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinewidth ( intcgm_line_att.width );
+
+   cgm_poly_circle ( center.x, center.y, radius, angi, angf, (close_type) ? CLOSED_CHORD : CLOSED_PIE );
+  }
+
+ if ( intcgm_edge_att.visibility==ON )
+  {
+   long int cor;
+
+   cor = cgm_getcolor ( intcgm_edge_att.color );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cgm_setlinewidth ( intcgm_edge_att.width );
+
+   cgm_line_circle ( center.x, center.y, radius, angi, angf, (close_type) ? CLOSED_CHORD : CLOSED_PIE );
+  }
+
+ return 0;
+}
+
+int cgm_do_ellips ( tpoint center, tpoint first_CDP, tpoint second_CDP )
+{
+ double w = myhypot ( first_CDP.x-center.x, first_CDP.y-center.y );
+ double h = myhypot ( second_CDP.x-center.x, second_CDP.y-center.y );
+ double inc =  atan2 ( first_CDP.y-center.y, first_CDP.x-center.x );
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = center.x - w;
+ bb_xmax = center.x + w;
+ bb_ymin = center.y - h;
+ bb_ymax = center.y + h;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_ElpArc ( center.x, center.y, w*2., h*2., inc, 0-inc, TWOPI-inc, 64, 2  );
+
+ return 0;
+}
+
+int cgm_do_ellarc ( tpoint center, tpoint first_CDP, tpoint second_CDP,
+                tpoint start, tpoint end )
+{
+ double w = myhypot ( first_CDP.x-center.x, first_CDP.y-center.y );
+ double h = myhypot ( second_CDP.x-center.x, second_CDP.y-center.y );
+ double inc = atan2 ( first_CDP.y-center.y, first_CDP.x-center.x );
+ double a1  = atan2 ( start.y, start.x );
+ double a2  = atan2 ( end.y, end.x );
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = center.x - w;
+ bb_xmax = center.x + w;
+ bb_ymin = center.y - h;
+ bb_ymax = center.y + h;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_ElpArc ( center.x, center.y, w*2., h*2., inc, a1-inc, a2-inc, 64, 0 );
+
+ return 0;
+}
+
+int cgm_do_ellacl ( tpoint center, tpoint first_CDP, tpoint second_CDP,
+                tpoint start, tpoint end, int close_type )
+{
+ double w = myhypot ( first_CDP.x-center.x, first_CDP.y-center.y );
+ double h = myhypot ( second_CDP.x-center.x, second_CDP.y-center.y );
+ double inc = atan2 ( first_CDP.y-center.y, first_CDP.x-center.x );
+ double a1  = atan2 ( start.y, start.x );
+ double a2  = atan2 ( end.y, end.x );
+
+ double bb_xmin, bb_ymin, bb_xmax, bb_ymax;
+
+ bb_xmin = center.x - w;
+ bb_xmax = center.x + w;
+ bb_ymin = center.y - h;
+ bb_ymax = center.y + h;
+
+#if 0
+ if ( cgm_vdcx2canvas(bb_xmin) > intcgm_view_xmax || cgm_vdcx2canvas(bb_xmax) < intcgm_view_xmin ||
+      cgm_vdcy2canvas(bb_ymin) > intcgm_view_ymax || cgm_vdcy2canvas(bb_ymax) < intcgm_view_ymin ) return 0;
+#else
+ if ( bb_xmin > intcgm_clip_xmax || bb_xmax < intcgm_clip_xmin ||
+      bb_ymin > intcgm_clip_ymax || bb_ymax < intcgm_clip_ymin ) return 0;
+#endif
+
+ cgm_ElpArc ( center.x, center.y, w*2., h*2., inc, a1-inc, a2-inc, 64, close_type+1 );
+
+ return 0;
+}
+
+int cgm_do_text_height ( double height )
+{
+ cgm_setfont ( intcgm_text_att.font, intcgm_text_att.style, height );
+
+ return 0;
+}
+
diff --git a/src/intcgm/intcgm4.h b/src/intcgm/intcgm4.h
new file mode 100644
index 0000000..4b12873
--- /dev/null
+++ b/src/intcgm/intcgm4.h
@@ -0,0 +1,28 @@
+int cgm_do_vdcext ( tpoint, tpoint );
+int cgm_do_bckcol ( trgb );
+int cgm_do_transp ( int );
+int cgm_do_clprec ( tpoint, tpoint );
+int cgm_do_clpind ( int );
+int cgm_do_polyln ( int, tpoint * );
+int cgm_do_incply ( int, tpoint * );
+int cgm_do_djtply ( int, tpoint * );
+int cgm_do_indpl ( int, tpoint * );
+int cgm_do_polymk ( int, tpoint * );
+int cgm_do_incplm ( int, tpoint * );
+int cgm_do_text ( int, char *, tpoint );
+int cgm_do_txtalign ( int hor, int ver );
+int cgm_do_polygn ( int, tpoint * );
+int cgm_do_incplg ( int, tpoint * );
+int cgm_do_plgset( int, int, tpoint *, short * );
+int cgm_do_cellar ( tpoint, tpoint, tpoint, int, int, long, tcolor * );
+int cgm_do_gdp ( int, tpoint *, char * );
+int cgm_do_rect ( tpoint point1, tpoint point2 );
+int cgm_do_circle ( tpoint, double );
+int cgm_do_circ3p ( tpoint, tpoint, tpoint );
+int cgm_do_circ3pc ( tpoint, tpoint, tpoint, int );
+int cgm_do_circcnt ( tpoint, tpoint, tpoint, double );
+int cgm_do_ccntcl ( tpoint, tpoint, tpoint, double, int );
+int cgm_do_ellips ( tpoint, tpoint, tpoint );
+int cgm_do_ellarc ( tpoint, tpoint, tpoint, tpoint, tpoint );
+int cgm_do_ellacl ( tpoint, tpoint, tpoint, tpoint, tpoint, int );
+int cgm_do_text_height ( double );
diff --git a/src/intcgm/intcgm6.c b/src/intcgm/intcgm6.c
new file mode 100644
index 0000000..c23afee
--- /dev/null
+++ b/src/intcgm/intcgm6.c
@@ -0,0 +1,253 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include <cd.h>
+
+#include "list.h"
+#include "types.h"
+#include "intcgm.h"
+#include "intcgm2.h"
+#include "intcgm6.h"
+
+void cgm_setlinestyle ( int type )
+{
+  switch ( type )
+  {
+  case LINE_SOLID:
+    cdCanvasLineStyle (intcgm_canvas,  CD_CONTINUOUS );
+    break;
+  case LINE_DASH:
+    cdCanvasLineStyle (intcgm_canvas,  CD_DASHED );
+    break;
+  case LINE_DOT:
+    cdCanvasLineStyle (intcgm_canvas,  CD_DOTTED );
+    break;
+  case LINE_DASH_DOT:
+    cdCanvasLineStyle (intcgm_canvas,  CD_DASH_DOT );
+    break;
+  case LINE_DASH_DOT_DOT:
+    cdCanvasLineStyle (intcgm_canvas,  CD_DASH_DOT_DOT );
+    break;
+  }
+}
+
+void cgm_setlinewidth ( double width )
+{
+  int w;
+  if ( intcgm_cgm.lnwsm == ABSOLUTE )
+    w = cgm_delta_vdc2canvas(width);
+  else
+    w = (int)floor ( width+0.5 );
+
+  cdCanvasLineWidth (intcgm_canvas,  w>0?w:1 );
+}
+
+void cgm_setmarktype ( int type )
+{
+  switch ( type )
+  {
+  case MARK_DOT:
+    cdCanvasMarkType (intcgm_canvas,  CD_STAR );
+    break;
+  case MARK_PLUS:
+    cdCanvasMarkType (intcgm_canvas,  CD_PLUS );
+    break;
+  case MARK_ASTERISK:
+    cdCanvasMarkType (intcgm_canvas,  CD_X );
+    break;
+  case MARK_CIRCLE:
+    cdCanvasMarkType (intcgm_canvas,  CD_CIRCLE );
+    break;
+  case MARK_CROSS:
+    cdCanvasMarkType (intcgm_canvas,  CD_PLUS );
+    break;
+  }
+}
+
+void cgm_setmarksize ( double size )
+{
+  if ( intcgm_cgm.lnwsm == ABSOLUTE )
+    cdCanvasMarkSize (intcgm_canvas,  cgm_delta_vdc2canvas(size) );
+  else
+    cdCanvasMarkSize (intcgm_canvas,  (int)floor ( size*0.5 ) );
+}
+
+long int *cgm_setpattern ( pat_table pat )
+{
+  int i;
+  long int *cor = (long int *) malloc ( pat.nx*pat.ny*sizeof(long int) );
+  
+  for ( i=0; i<pat.nx*pat.ny ; i++ )
+    cor[i] = cgm_getcolor ( pat.pattern[i] );
+  
+  return cor;
+}
+
+int cgm_setintstyle ( int style )
+{
+  if ( style==HOLLOW )
+    return CD_CLOSED_LINES;
+  else if ( style==SOLID )
+  {
+    cdCanvasInteriorStyle (intcgm_canvas,  CD_SOLID );
+    return CD_FILL;
+  }
+  else if ( style==PATTERN )
+  {
+    int i;
+    pat_table *pat;
+    long int *p;
+    
+    for ( i=1; (pat=(pat_table *)cgm_GetList( intcgm_fill_att.pat_list,i ))!=NULL; i++ )
+    {
+      if ( pat->index==intcgm_fill_att.pat_index ) break;
+    }
+    
+    p = (long int *) malloc ( pat->nx*pat->ny*sizeof(long int) );
+    
+    for ( i=0; i<pat->nx*pat->ny; i++ )
+    {
+      if ( intcgm_cgm.clrsm==DIRECT )
+        p[i] = cdEncodeColor ((unsigned char)(pat->pattern[i].rgb.red*255./intcgm_cgm.color_ext.white.red),
+                              (unsigned char)(pat->pattern[i].rgb.green*255./intcgm_cgm.color_ext.white.green),
+                              (unsigned char)(pat->pattern[i].rgb.blue*255./intcgm_cgm.color_ext.white.blue) );
+      else
+        p[i] = cdEncodeColor ((unsigned char)(intcgm_color_table[pat->pattern[i].ind].red*255/intcgm_cgm.color_ext.white.red),
+                              (unsigned char)(intcgm_color_table[pat->pattern[i].ind].green*255/intcgm_cgm.color_ext.white.green),
+                              (unsigned char)(intcgm_color_table[pat->pattern[i].ind].blue*255/intcgm_cgm.color_ext.white.blue) );
+    }
+    
+    cdCanvasPattern(intcgm_canvas,  pat->nx, pat->ny, (long *) p );
+    
+    return CD_FILL;
+  }
+  else if ( style==HATCH )
+  {
+    cdCanvasHatch (intcgm_canvas,  intcgm_fill_att.hatch_index-1 );
+    return CD_FILL;
+  }
+  else
+    return CD_CLOSED_LINES;
+}
+
+long int cgm_getcolor ( tcolor cor )
+{
+  
+  if ( intcgm_cgm.clrsm==INDEXED )
+    return cdEncodeColor ((unsigned char)(intcgm_color_table[cor.ind].red*255/intcgm_cgm.color_ext.white.red),
+                          (unsigned char)(intcgm_color_table[cor.ind].green*255/intcgm_cgm.color_ext.white.green),
+                          (unsigned char)(intcgm_color_table[cor.ind].blue*255/intcgm_cgm.color_ext.white.blue) );
+  else
+    return cdEncodeColor ((unsigned char)(cor.rgb.red*255/intcgm_cgm.color_ext.white.red),
+                          (unsigned char)(cor.rgb.green*255/intcgm_cgm.color_ext.white.green),
+                          (unsigned char)(cor.rgb.blue*255/intcgm_cgm.color_ext.white.blue) );
+}
+
+int cgm_vdcx2canvas ( double vdc )
+{
+  if ( intcgm_cgm.drawing_mode==ABSTRACT )
+    return (int) floor ( intcgm_scale_factor_x*(vdc-intcgm_vdc_ext.xmin)+.5 ) + intcgm_view_xmin;
+  else
+    return (int) floor ( intcgm_scale_factor_mm_x*(vdc-intcgm_vdc_ext.xmin)*intcgm_cgm.scaling_mode.scale_factor +
+                         intcgm_vdc_ext.xmin*intcgm_cgm.scaling_mode.scale_factor + .5 );
+}
+
+int cgm_vdcy2canvas ( double vdc )
+{
+  if ( intcgm_cgm.drawing_mode==ABSTRACT )
+    return (int) floor ( intcgm_scale_factor_y*(vdc-intcgm_vdc_ext.ymin)+.5 ) + intcgm_view_ymin;
+  else
+    return (int) floor ( intcgm_scale_factor_mm_y*(vdc-intcgm_vdc_ext.ymin)*intcgm_cgm.scaling_mode.scale_factor +
+                         intcgm_vdc_ext.ymin*intcgm_cgm.scaling_mode.scale_factor + .5 );
+}
+
+int cgm_delta_vdc2canvas ( double vdc )
+{
+  int delta = (int) cgm_vdcx2canvas(intcgm_vdc_ext.xmin+vdc) - (int) cgm_vdcx2canvas(intcgm_vdc_ext.xmin);
+  return delta;
+}
+
+double cgm_canvas2vdcx ( int x )
+{
+  if ( intcgm_cgm.drawing_mode==ABSTRACT )
+    return (double) (x-intcgm_view_xmin)/intcgm_scale_factor_x + intcgm_vdc_ext.xmin;
+  else
+    return (double) (x-intcgm_view_xmin)/(intcgm_scale_factor_mm_x*intcgm_cgm.scaling_mode.scale_factor) + intcgm_vdc_ext.xmin;
+}
+
+double cgm_canvas2vdcy ( int y )
+{
+  if ( intcgm_cgm.drawing_mode==ABSTRACT )
+    return (double) (y-intcgm_view_ymin)/intcgm_scale_factor_y + intcgm_vdc_ext.ymin;
+  else
+    return (double) (y-intcgm_view_ymin)/(intcgm_scale_factor_mm_y*intcgm_cgm.scaling_mode.scale_factor) + intcgm_vdc_ext.ymin;
+}
+
+void cgm_getpolybbox ( tpoint *pt, int n_points, double *bb_xmin, double *bb_ymin,
+                  double *bb_xmax, double *bb_ymax )
+{
+  int i;
+  
+  *bb_xmin = *bb_xmax = pt[0].x;
+  *bb_ymin = *bb_ymax = pt[0].y;
+  
+  for ( i=1; i<n_points; i++)
+  {
+    if ( pt[i].x < *bb_xmin ) *bb_xmin = pt[i].x;
+    else if ( pt[i].x > *bb_xmax ) *bb_xmax = pt[i].x;
+    if ( pt[i].y < *bb_ymin ) *bb_ymin = pt[i].y;
+    else if ( pt[i].y > *bb_ymax ) *bb_ymax = pt[i].y;
+  }
+}
+
+void cgm_getincpolybbox ( tpoint *pt, int n_points, double *bb_xmin, double *bb_ymin,
+                     double *bb_xmax, double *bb_ymax )
+{
+  int i;
+  double px, py;
+  
+  px = *bb_xmin = *bb_xmax = pt[0].x;
+  py = *bb_ymin = *bb_ymax = pt[0].y;
+  
+  for ( i=1; i<n_points; i++)
+  {
+    px += pt[i].x;   py += pt[i].y;
+    if ( px < *bb_xmin ) *bb_xmin = px;
+    else if ( px > *bb_xmax ) *bb_xmax = px;
+    if ( py < *bb_ymin ) *bb_ymin = py;
+    else if ( py > *bb_ymax ) *bb_ymax = py;
+  }
+}
+
+int cgm_setfont ( int font, int style, double height )
+{
+  int size;
+  int cy;
+  char* type_face;
+  
+  cy = cgm_delta_vdc2canvas ( height );
+  size = (int) floor (((cy/intcgm_scale_factor_mm_y)/0.353)+0.5);
+  switch (font)
+  {
+  case 0:
+    type_face = "System";
+    break;
+  case 1:
+    type_face = "Courier";
+    break;
+  case 2:
+    type_face = "Times";
+    break;
+  case 3:
+    type_face = "Helvetica";
+    break;
+  default:
+    return 0;
+  }
+  
+  cdCanvasFont(intcgm_canvas, type_face, style, size );
+  
+  return 0;
+}
diff --git a/src/intcgm/intcgm6.h b/src/intcgm/intcgm6.h
new file mode 100644
index 0000000..fde660e
--- /dev/null
+++ b/src/intcgm/intcgm6.h
@@ -0,0 +1,15 @@
+void cgm_setlinestyle ( int );
+void cgm_setlinewidth ( double );
+void cgm_setmarktype ( int );
+void cgm_setmarksize ( double );
+long int cgm_getcolor ( tcolor );
+long int *cgm_setpattern ( pat_table );
+int cgm_setfont ( int, int, double );
+int cgm_setintstyle ( int );
+int cgm_vdcx2canvas ( double );
+int cgm_vdcy2canvas ( double );
+int cgm_delta_vdc2canvas ( double );
+double cgm_canvas2vdcx ( int );
+double cgm_canvas2vdcy ( int );
+void cgm_getpolybbox ( tpoint *, int, double *n, double *, double *, double * );
+void cgm_getincpolybbox ( tpoint *, int, double *, double *, double *, double * );
diff --git a/src/intcgm/list.c b/src/intcgm/list.c
new file mode 100644
index 0000000..6fefbbc
--- /dev/null
+++ b/src/intcgm/list.c
@@ -0,0 +1,117 @@
+/*
+* list.c
+* Generic List Manager
+* TeCGraf
+*
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "list.h"
+
+TList *cgm_NewList ( void )
+{
+ TList *l = (TList *) malloc ( sizeof (TList) );
+
+ list_nba(l) = 8;
+ list_head(l) = (void **)malloc(list_nba(l)*sizeof(void*));
+ list_n(l) = 0;
+
+ return l;
+}
+
+TList *cgm_AppendList ( TList *l, void *i )
+{
+ if ( l == NULL )
+   return NULL;
+
+ if (list_n(l) == list_nba(l))
+ {
+  list_nba(l) += 32;
+  list_head(l) = (void **)realloc(list_head(l),list_nba(l)*sizeof(void*));
+ }
+
+ list_head(l)[list_n(l)]=i;
+ list_n(l)++;
+
+ return l;
+}
+
+TList *cgm_AddList ( TList *l, int n, void *info )
+{
+ int i;
+
+ if ( l == NULL)
+   return NULL;
+
+ if ( n < 1)
+  n=1;
+
+ if ( n > list_n(l) )
+   return cgm_AppendList( l, info );
+
+ --n;           /* o usuario ve a lista iniciando em 1 e a */
+                /* lista e' implementada iniciando em 0     */
+
+ if (list_n(l) == list_nba(l))
+ {
+  list_nba(l) *= 2;
+  list_head(l) = (void **)realloc(list_head(l),list_nba(l)*sizeof(void*));
+ }
+
+ for (i=list_n(l)-1; i>=n; --i)
+   list_head(l)[i+1]=list_head(l)[i];
+
+ list_head(l)[n]=info;
+ list_n(l)++;
+ return l;
+}
+
+TList *cgm_DelList ( TList *l, int n )
+{
+ int i;
+
+ if ( l == NULL || list_n(l) == 0 || n < 0)
+   return NULL;
+
+ if ( n < 1)
+  n=1;
+
+ if ( n > list_n(l))
+  n=list_n(l);
+
+ --n;           /* o usuario ve a lista iniciando em 1 e a */
+                /* lista e' implementada iniciando em 0     */
+ list_n(l)--;
+
+ for (i=n; i<list_n(l); ++i)
+   list_head(l)[i]=list_head(l)[i+1];
+
+ return l;
+}
+
+void *cgm_GetList ( TList *l, int n )
+{
+ if ( l == NULL || n <= 0)
+   return NULL;
+
+ return n > list_n(l) ? NULL : list_head(l)[n-1];
+}
+
+int cgm_DelEntry ( TList *l, void *entry )
+{
+ int i=1;
+
+ if ( l == NULL || list_n(l) == 0)
+   return 0;
+
+ for (i=0; i< list_n(l); ++i)
+  if (list_head(l)[i]==entry)
+  {
+   cgm_DelList(l,i+1);              /* o usuario ve a lista iniciando em 1 e a */
+                                /* lista e' implementada iniciando em 0     */
+   return i+1;
+  }
+ return 0;
+}
+
diff --git a/src/intcgm/list.h b/src/intcgm/list.h
new file mode 100644
index 0000000..c661a7c
--- /dev/null
+++ b/src/intcgm/list.h
@@ -0,0 +1,30 @@
+
+/*
+* list.h
+* prototipos das funcoes de manipulacao de lista
+* TeCGraf
+* 27 Ago 93
+*/
+
+#ifndef __LIST_H__
+#define __LIST_H__
+
+typedef struct TList_
+	{
+	 void **h;     /* head */
+         int nba;
+         int n;     /* Numero de elementos na lista */
+	} TList;
+
+#define list_head(l)	    ((l)->h)
+#define list_n(l)        ((l)->n)
+#define list_nba(l)        ((l)->nba)
+
+TList *cgm_NewList    ( void );
+TList *cgm_AppendList ( TList *, void * );
+TList *cgm_AddList    ( TList *, int, void * );
+TList *cgm_DelList    ( TList *, int );
+void  *cgm_GetList    ( TList *, int );
+int   cgm_DelEntry    ( TList *, void * );
+
+#endif
diff --git a/src/intcgm/sism.c b/src/intcgm/sism.c
new file mode 100644
index 0000000..9946ac3
--- /dev/null
+++ b/src/intcgm/sism.c
@@ -0,0 +1,392 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <limits.h>
+#include <float.h>
+
+#include <cd.h>
+
+#include "list.h"
+#include "types.h"
+#include "intcgm.h"
+#include "intcgm2.h"
+#include "intcgm6.h"
+
+static tpoint trace_start_pos, base_direction, amp_direction, trace_direction;
+static double bline_sc_f, amp_sc_f, trc_st_f, VA_bline_offset, pos_clp_lmt,
+             neg_clp_lmt, pos_bckfil_bnd, neg_bckfil_bnd;
+static int trace_dsp_md, samp_type, n_samp, wig_trc_mod, nul_clr_i, n_trace;
+static double *sample;
+static long *coind;
+static int trace=0;
+
+void cgm_sism4 ( tpoint *pt, char *data_rec )
+{
+ sscanf ( data_rec, "%lg %lg %lg %lg %lg %lg %d %d %d %lg %lg %*d %d %d %d",
+          &bline_sc_f, &amp_sc_f, &trc_st_f, &VA_bline_offset, &pos_clp_lmt,
+          &neg_clp_lmt, &trace_dsp_md, &samp_type, &n_samp, &pos_bckfil_bnd, 
+          &neg_bckfil_bnd, &wig_trc_mod, &nul_clr_i, &n_trace );
+
+ trace_start_pos = pt[0];
+ base_direction = pt[1];
+ amp_direction = pt[2];
+ trace_direction = pt[3];
+ trace = 0;
+}
+
+/*     adjust the samples to the amplitude direction vector */
+static void dirvet ( double dx )
+{
+ int i;
+
+ for ( i=0; i<n_samp; i++ )
+  sample[i] *= dx/fabs(dx);
+}
+
+/*     adust the x offset from the baseline to maximum amplitude */
+static void ampscf ( double dx )
+{
+ double max=1;
+ int i;
+
+ if ( samp_type == 0 || samp_type == 4 ) max = (double) SHRT_MAX;
+ else if ( samp_type == 1 ) max = (double) INT_MAX;
+ else if ( samp_type == 2 ) max = (double) FLT_MAX;
+ else if ( samp_type == 3 || samp_type == 5 ) max = (double) SCHAR_MAX;
+
+ for ( i=0; i<n_samp; i++ )
+  sample[i] = (sample[i]/max) * amp_sc_f * dx;
+}
+
+static double interpl ( int i, double y1, double y2, double x )
+{
+ return ( y1*(x-sample[i+1]) + y2*(sample[i]-x) ) / ( sample[i]-sample[i+1] );
+}
+
+static void vasamp ( int mode, double max, double min, int cordep )
+{
+ double factx, facty;
+ double x[5], y[5];
+ double samp1, samp2, mn, mx;
+ long int cor;
+ int i,j,n;
+
+ facty = base_direction.y * bline_sc_f;
+ factx = trace_direction.x * trc_st_f;
+
+ max *= amp_sc_f;
+ min *= amp_sc_f;
+ mn = min;
+ mx = max;
+
+ if ( mode==64 )
+  {
+   double tmp = min;
+   min = max;
+   max = tmp;
+   mn = min * -1.;
+   mx = max * -1.;
+  }
+
+ for ( i=0; i<(n_samp-1); i++ )
+  {
+   double y1 = trace_start_pos.y + facty*(i);
+   double y2 = trace_start_pos.y + facty*(i+1);
+   double dx = trace_start_pos.x + factx*(trace-1);
+   
+   samp1 = sample[i];
+   samp2 = sample[i+1];
+
+   if ( mode==64 )
+    {
+     samp1 *= -1.;
+     samp2 *= -1.;
+    }
+
+   n=0;
+
+   if (samp1<mn && samp2>mn && samp2<mx)
+    {
+     x[n]   = min + dx;
+     y[n++] = interpl(i,y1,y2,min);
+     x[n]   = sample[i+1] + dx;
+     y[n++] = y2;
+     x[n]   = min + dx;
+     y[n++] = y2;
+    }
+
+   else if (samp1<mn && samp2>mx)
+    {
+     x[n]   = min + dx;
+     y[n++] = interpl(i,y1,y2,min);
+     x[n]   = max + dx;
+     y[n++] = interpl(i,y1,y2,max);
+     x[n]   = max + dx;
+     y[n++] = y2;
+     x[n]   = min + dx;
+     y[n++] = y2;
+    }
+
+   else if ( (samp1>mn && samp1<mx) &&
+             (samp2>mn && samp2<mx) )
+    {
+     x[n]   = min + dx;
+     y[n++] = y1;
+     x[n]   = sample[i] + dx;
+     y[n++] = y1;
+     x[n]   = sample[i+1] + dx;
+     y[n++] = y2;
+     x[n]   = min + dx;
+     y[n++] = y2;
+    }
+
+   else if ( samp1>mn && samp1<mx && samp2>mx )
+    {
+     x[n]   = min + dx;
+     y[n++] = y1;
+     x[n]   = sample[i] + dx;
+     y[n++] = y1;
+     x[n]   = max + dx;
+     y[n++] = interpl(i,y1,y2,max);
+     x[n]   = max + dx;
+     y[n++] = y2;
+     x[n]   = min + dx;
+     y[n++] = y2;
+    }
+
+   else if ( samp1>mx && samp2>mx )
+    {
+     x[n]   = min + dx;
+     y[n++] = y1;
+     x[n]   = max + dx;
+     y[n++] = y1;
+     x[n]   = max + dx;
+     y[n++] = y2;
+     x[n]   = min + dx;
+     y[n++] = y2;
+    }
+
+   else if ( samp1>mx && samp2<mx && samp2>mn )
+    {
+     x[n]   = min + dx;
+     y[n++] = y1;
+     x[n]   = max + dx;
+     y[n++] = y1;
+     x[n]   = max + dx;
+     y[n++] = interpl(i,y1,y2,max);
+     x[n]   = sample[i+1] + dx;
+     y[n++] = y2;
+     x[n]   = min + dx;
+     y[n++] = y2;
+    }
+
+   else if ( samp1>mn && samp1<mx && samp2<mn )
+    {
+     x[n]   = min + dx;
+     y[n++] = y1;
+     x[n]   = sample[i] + dx;
+     y[n++] = y1;
+     x[n]   = min + dx;
+     y[n++] = interpl(i,y1,y2,min);
+    }
+
+   if ( n>0 )
+    {
+     if ( cordep )
+      {
+       cor = cdEncodeColor ( (unsigned char)((intcgm_color_table[coind[i]].red*255)/intcgm_cgm.color_ext.white.red),
+                             (unsigned char)((intcgm_color_table[coind[i]].green*255)/intcgm_cgm.color_ext.white.green),
+                             (unsigned char)((intcgm_color_table[coind[i]].blue*255)/intcgm_cgm.color_ext.white.blue) );
+       cdCanvasSetForeground (intcgm_canvas,  cor );
+      }
+
+     cdCanvasBegin(intcgm_canvas,  CD_FILL );
+
+     for ( j=0; j<n; j++ )
+      cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(x[j]), cgm_vdcy2canvas(y[j]) );
+
+     cdCanvasEnd(intcgm_canvas);
+    }
+  }
+}
+
+static void bgclfl ( int mode )
+{
+ double factx, facty;
+ double posdx, negdx;
+ long int cor;
+ int i;
+
+ facty = base_direction.y * bline_sc_f;
+ factx = trace_direction.x * trc_st_f;
+
+ posdx = pos_bckfil_bnd * amp_sc_f * amp_direction.x;
+ negdx = neg_bckfil_bnd * amp_sc_f * amp_direction.x;
+
+ cdCanvasInteriorStyle(intcgm_canvas,  CD_SOLID );
+
+ for ( i=0; i<n_samp; i++ )
+  {
+   int index = ( coind[i] <= intcgm_cgm.max_cix ) ? coind[i] : 1;
+
+   cor = cdEncodeColor ( (unsigned char)((intcgm_color_table[index].red*255)/intcgm_cgm.color_ext.white.red),
+                         (unsigned char)((intcgm_color_table[index].green*255)/intcgm_cgm.color_ext.white.green),
+                         (unsigned char)((intcgm_color_table[index].blue*255)/intcgm_cgm.color_ext.white.blue) );
+   cdCanvasSetForeground (intcgm_canvas,  cor );
+
+   cdCanvasBegin(intcgm_canvas,  CD_FILL );
+
+   cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(posdx + trace_start_pos.x + factx*(trace-1)),
+              cgm_vdcy2canvas(trace_start_pos.y + facty*(i)) );
+   cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(posdx + trace_start_pos.x + factx*(trace-1)),
+              cgm_vdcy2canvas(trace_start_pos.y + facty*(i+1)) );
+   cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(negdx + trace_start_pos.x + factx*(trace-1)),
+              cgm_vdcy2canvas(trace_start_pos.y + facty*(i+1)) );
+   cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(negdx + trace_start_pos.x + factx*(trace-1)),
+              cgm_vdcy2canvas(trace_start_pos.y + facty*(i)) );
+
+   cdCanvasEnd(intcgm_canvas);
+  }
+}
+
+void wiggle ( double posclp, double negclp )
+{
+ int i;
+ double facty = base_direction.y * bline_sc_f;
+ double factx = trace_direction.x * trc_st_f;
+ double dx = trace_start_pos.x + factx*(trace-1);
+
+ posclp *= amp_sc_f;
+ negclp *= amp_sc_f;
+
+ cdCanvasBegin(intcgm_canvas,  CD_OPEN_LINES );
+
+ for ( i=0; i<n_samp; i++ )
+  {
+   double y1 = trace_start_pos.y + facty*(i);
+   double y2 = trace_start_pos.y + facty*(i+1);
+
+   if ( sample[i]>negclp && sample[i]<posclp && 
+        sample[i+1]>negclp && sample[i+1]<posclp )
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(sample[i] + dx), cgm_vdcy2canvas(y1) );
+   else if ( sample[i]<negclp && sample[i+1]>negclp && sample[i+1]<posclp )
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(negclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,negclp)) );
+   else if ( sample[i]<negclp && sample[i+1]>posclp )
+    {
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(negclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,negclp)) );
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(posclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,posclp)) );
+    }
+   else if ( sample[i]>negclp && sample[i]<posclp && sample[i+1]>posclp )
+    {
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(sample[i] + dx), cgm_vdcy2canvas(y1) );
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(posclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,posclp)) );
+    }
+   else if ( sample[i]>posclp && sample[i+1]<posclp && sample[i+1]>negclp )
+    cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(posclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,posclp)) );
+   else if ( sample[i]>posclp && sample[i+1]<negclp )
+    {
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(posclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,posclp)) );
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(negclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,negclp)) );
+    }
+   else if ( sample[i]>negclp && sample[i]<posclp && sample[i+1]<negclp )
+    {
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(sample[i] + dx), cgm_vdcy2canvas(y1) );
+     cdCanvasVertex (intcgm_canvas,  cgm_vdcx2canvas(negclp + dx), cgm_vdcy2canvas(interpl(i,y1,y2,negclp)) );
+    }
+  }
+
+ cdCanvasEnd(intcgm_canvas);
+}
+
+void cgm_sism5 ( char *data_rec )
+{
+ int i, mode, trace_mode;
+ double pos_clp, neg_clp;
+
+ sample = (double *) malloc ( n_samp*sizeof(double) );
+
+ if ( trace_dsp_md > 7 )
+  coind = (long *) malloc ( n_samp*sizeof(long) );
+ 
+ for ( i=0; i<n_samp; i++ )
+  if ( trace_dsp_md < 8 )
+    sample[i] = strtod ( data_rec, &data_rec );
+  else
+   {
+    sample[i] = (double) strtol ( data_rec, &data_rec, 10 );
+    coind[i] = strtol ( data_rec, &data_rec, 10 );
+   }
+
+ trace += 1;
+
+ dirvet ( amp_direction.x );
+
+ ampscf ( amp_direction.x );
+
+ trace_mode = trace_dsp_md;
+
+ do
+  {
+
+   if ( trace_mode >= 64 )
+    mode = 64;
+   else if ( trace_mode >= 32 )
+    mode = 32;
+   else if ( trace_mode >= 16 )
+    mode = 16;
+   else if ( trace_mode >= 8 )
+    mode = 8;
+   else if ( trace_mode >= 4 )
+    mode = 4;
+   else if ( trace_mode >= 2 )
+    mode = 2;
+   else if ( trace_mode == 1 )
+    mode = 1;
+
+   switch ( mode )
+    {
+     case 64:
+      neg_clp = neg_clp_lmt;
+      pos_clp = ( pos_clp_lmt < 0 ) ?  pos_clp_lmt : 0;
+      vasamp ( mode, pos_clp, neg_clp, 1 );
+      trace_mode -= 64;
+      break;
+     case 32:
+      neg_clp = ( neg_clp_lmt > 0 ) ? neg_clp_lmt : 0;
+      pos_clp = pos_clp_lmt;
+      vasamp ( mode, pos_clp, neg_clp, 1 );
+      trace_mode -= 32;
+      break;
+     case 16:
+      bgclfl( mode );
+      trace_mode -= 16;
+      break;
+     case  8:
+      bgclfl( mode );
+      trace_mode -= 8;
+      break;
+     case  4:
+      neg_clp = ( neg_clp_lmt > 0 ) ? neg_clp_lmt : 0;
+      pos_clp = pos_clp_lmt;
+      vasamp ( mode, pos_clp, neg_clp, 0 );
+      trace_mode -= 4;
+      break;
+     case  2:
+      neg_clp = ( neg_clp_lmt > 0 ) ? neg_clp_lmt : 0;
+      pos_clp = pos_clp_lmt;
+      vasamp ( mode, pos_clp, neg_clp, 0 );
+      trace_mode -= 2;
+      break;
+     case  1:
+      wiggle ( pos_clp_lmt, neg_clp_lmt );
+      trace_mode -= 1;
+      break;
+    }
+  } while ( trace_mode != 0 );
+
+ free(sample);
+
+ if ( trace_dsp_md > 7 )
+  free(coind);
+}
diff --git a/src/intcgm/sism.h b/src/intcgm/sism.h
new file mode 100644
index 0000000..f2f08f0
--- /dev/null
+++ b/src/intcgm/sism.h
@@ -0,0 +1,3 @@
+void cgm_sism4 ( tpoint *, char * );
+void cgm_sism5 ( char * );
+
diff --git a/src/intcgm/tparse.c b/src/intcgm/tparse.c
new file mode 100644
index 0000000..0402ce6
--- /dev/null
+++ b/src/intcgm/tparse.c
@@ -0,0 +1,1370 @@
+#define _INTCGM2_C_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <cd.h>
+#include <cdcgm.h>
+
+#include "list.h"
+#include "types.h"
+#include "bparse.h"
+#include "intcgm.h"
+#include "intcgm2.h"
+#include "intcgm4.h"
+#include "intcgm6.h"
+
+int cgmt_begmtf ( void ) /* begin metafile */
+{
+ char *str=NULL;
+
+ if ( cgmt_s ( &str ) ) return 1;
+
+ if (cdcgmbegmtfcb)
+  {
+   int err;
+   err = cdcgmbegmtfcb ( intcgm_canvas, &intcgm_view_xmin, &intcgm_view_ymin, &intcgm_view_xmax, &intcgm_view_ymax );
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+ free(str);
+
+ return cgmt_ter();
+}
+
+int cgmt_endmtf ( void ) /* end metafile */
+{
+ cgmt_ter();
+ return 1;
+}
+
+int cgmt_begpic ( void ) /* begin picture */
+{
+ char *string=NULL;
+ 
+ if ( intcgm_cgm.first ) 
+  intcgm_cgm.first = 0;
+ else
+  cdCanvasFlush(intcgm_canvas);
+  
+ cdCanvasClip(intcgm_canvas, CD_CLIPAREA);
+ 
+ if ( cgmt_s ( &string ) ) return 1;
+
+  if (cdcgmbegpictcb)
+  {
+   int err;
+   err = cdcgmbegpictcb ( intcgm_canvas, string );
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+ free(string);
+
+ return cgmt_ter();
+}
+
+int cgmt_begpib ( void ) /* begin picture body */
+{
+ if (cdcgmbegpictbcb)
+  {
+   int err;
+   err = cdcgmbegpictbcb ( intcgm_canvas, 1., 1., intcgm_scale_factor_x, intcgm_scale_factor_y,
+	                       intcgm_scale_factor_mm_x*intcgm_cgm.scaling_mode.scale_factor,
+	                       intcgm_scale_factor_mm_y*intcgm_cgm.scaling_mode.scale_factor,
+						   intcgm_cgm.drawing_mode,
+						   intcgm_vdc_ext.xmin, intcgm_vdc_ext.ymin, intcgm_vdc_ext.xmax, intcgm_vdc_ext.ymax );
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+
+ if (cdcgmsizecb)
+  {
+   int err, w, h;
+   double w_mm=0., h_mm=0.;
+
+   w = intcgm_view_xmax-intcgm_view_xmin+1;
+   h = intcgm_view_ymax-intcgm_view_ymin+1;
+
+   if ( intcgm_cgm.vdc_type==INTEGER )
+    {
+	 w = (int) (intcgm_cgm.vdc_ext.second.x - intcgm_cgm.vdc_ext.first.x);
+	 h = (int) (intcgm_cgm.vdc_ext.second.y - intcgm_cgm.vdc_ext.first.y);
+	 if ( intcgm_cgm.scaling_mode.mode==METRIC )
+	  {
+	   w_mm = w * intcgm_cgm.scaling_mode.scale_factor;
+	   h_mm = h * intcgm_cgm.scaling_mode.scale_factor;
+	  }
+	}
+   else
+    {
+	 if ( intcgm_cgm.scaling_mode.mode==METRIC )
+	  {
+	   w_mm = (intcgm_cgm.vdc_ext.second.x - intcgm_cgm.vdc_ext.first.x) * intcgm_cgm.scaling_mode.scale_factor;
+	   h_mm = (intcgm_cgm.vdc_ext.second.y - intcgm_cgm.vdc_ext.first.y) * intcgm_cgm.scaling_mode.scale_factor;
+	  }
+	}
+
+   err = cdcgmsizecb ( intcgm_canvas, w, h, w_mm, h_mm );
+   if ( err==CD_ABORT ) return -1; 
+  }
+
+ return cgmt_ter();
+}
+
+int cgmt_endpic ( void ) /* end picture */
+{
+ return cgmt_ter();
+}
+
+int cgmt_mtfver ( void )   /* metafile version */
+{
+ long version;
+
+ if ( cgmt_i ( &version ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_mtfdsc ( void )   /* metafile description */
+{
+ char *string=NULL;
+
+ if ( cgmt_s ( &string ) ) return 1;
+
+ free(string);
+
+ return cgmt_ter();
+}
+
+int cgmt_vdctyp ( void )  /* vdc type */
+{
+ const char *options[] = { "integer", "real", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.vdc_type), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_intpre ( void )   /* integer precision */
+{
+ if ( cgmt_i ( &(intcgm_cgm.int_prec.t_prec.minint) ) ) return 1;
+ if ( cgmt_i ( &(intcgm_cgm.int_prec.t_prec.maxint) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_realpr ( void )   /* real precision */
+{
+ if ( cgmt_r ( &(intcgm_cgm.real_prec.t_prec.minreal) ) ) return 1;
+ if ( cgmt_r ( &(intcgm_cgm.real_prec.t_prec.maxreal) ) ) return 1;
+ if ( cgmt_i ( &(intcgm_cgm.real_prec.t_prec.digits) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_indpre ( void )   /* index precision */
+{
+ if ( cgmt_i ( &(intcgm_cgm.ix_prec.t_prec.minint) ) ) return 1;
+ if ( cgmt_i ( &(intcgm_cgm.ix_prec.t_prec.maxint) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_colpre ( void )   /* colour precision */
+{
+ if ( cgmt_i ( &(intcgm_cgm.cd_prec) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_colipr ( void )   /* colour index precision */
+{
+ if ( cgmt_i ( &(intcgm_cgm.cix_prec) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_maxcoi ( void )   /* maximum colour index */
+{
+ if ( cgmt_i ( &(intcgm_cgm.max_cix) ) ) return 1;
+
+ intcgm_color_table = (trgb *) realloc ( intcgm_color_table, sizeof(trgb)*(intcgm_cgm.max_cix+1) );
+
+ intcgm_color_table[0].red   = 255;
+ intcgm_color_table[0].green = 255;
+ intcgm_color_table[0].blue  = 255;
+ intcgm_color_table[1].red   = 0;
+ intcgm_color_table[1].green = 0;
+ intcgm_color_table[1].blue  = 0;
+
+ return cgmt_ter();
+}
+
+int cgmt_covaex ( void )   /* colour value extent */
+{
+ if ( cgmt_rgb ( &(intcgm_cgm.color_ext.black.red), &(intcgm_cgm.color_ext.black.green), &(intcgm_cgm.color_ext.black.blue) ) ) return 1;
+
+ if ( cgmt_rgb ( &(intcgm_cgm.color_ext.white.red), &(intcgm_cgm.color_ext.white.green), &(intcgm_cgm.color_ext.white.blue) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_mtfell ( void )   /* metafile element list */
+{
+ char *elist=NULL;
+
+ if ( cgmt_s ( &elist ) ) return 1;
+
+ free(elist);
+
+ return cgmt_ter();
+}
+
+int cgmt_bmtfdf (void )   /* begin metafile defaults */
+{
+ return cgmt_ter();
+}
+
+int cgmt_emtfdf ( void )   /* end metafile defaults */
+{
+ return cgmt_ter();
+}
+
+int cgmt_fntlst ( void )   /* font list */
+{
+ char *font=NULL;
+
+ if ( intcgm_text_att.font_list==NULL ) intcgm_text_att.font_list = cgm_NewList();
+
+ while ( cgmt_ter() ) 
+  {
+   if ( cgmt_s ( &font ) ) return 1;
+   cgm_AppendList ( intcgm_text_att.font_list, font );
+  }
+
+ return 0;
+}
+
+int cgmt_chslst ( void )  /* character set list */
+{
+ const char *options[] = { "std94", "std96", "std94multibyte", "std96multibyte",
+                           "completecode", NULL };
+ char *tail;
+ short code;
+
+ do
+  {
+   if ( cgmt_e ( &(code), options ) ) return 1;
+
+   if ( cgmt_s ( &tail ) ) return 1;
+
+   free ( tail );
+
+  } while ( cgmt_ter() );
+
+ return 0;
+}
+
+int cgmt_chcdac ( void )   /* character coding announcer */
+{
+ const char *options[] = { "basic7bit", "basic8bit", "extd7bit", "extd8bit", NULL };
+ short code;
+
+ if ( cgmt_e ( &(code), options ) ) return 1;
+
+ return cgmt_ter ();
+}
+
+int cgmt_sclmde ( void )   /* scaling mode */
+{
+ const char *options[] = { "abstract", "metric", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.scaling_mode.mode), options ) ) return 1;
+
+ if ( cgmt_r ( &(intcgm_cgm.scaling_mode.scale_factor) ) ) return 1;
+
+ if ( intcgm_cgm.scaling_mode.mode==ABSTRACT ) intcgm_cgm.scaling_mode.scale_factor=1.;
+
+ intcgm_cgm.drawing_mode = ABSTRACT;
+  
+ if (cdcgmsclmdecb) 
+  {
+   int err;
+   err = cdcgmsclmdecb ( intcgm_canvas, intcgm_cgm.scaling_mode.mode, &intcgm_cgm.drawing_mode, &intcgm_cgm.scaling_mode.scale_factor );
+   if ( err==CD_ABORT ) return -1;
+  }
+
+ if ( intcgm_cgm.drawing_mode==ABSTRACT )
+  {
+   intcgm_clip_xmin = cgm_canvas2vdcx ( intcgm_view_xmin );
+   intcgm_clip_xmax = cgm_canvas2vdcx ( intcgm_view_xmax );
+   intcgm_clip_ymin = cgm_canvas2vdcy ( intcgm_view_ymin );
+   intcgm_clip_ymax = cgm_canvas2vdcy ( intcgm_view_ymax );
+  }
+ else
+  {
+   intcgm_clip_xmin = intcgm_vdc_ext.xmin*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_xmax = intcgm_vdc_ext.xmax*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_ymin = intcgm_vdc_ext.ymin*intcgm_cgm.scaling_mode.scale_factor;
+   intcgm_clip_ymax = intcgm_vdc_ext.ymax*intcgm_cgm.scaling_mode.scale_factor;
+  }
+  
+ return cgmt_ter();
+}
+
+int cgmt_clslmd ( void )   /* colour selection mode */
+{
+ const char *options[] = { "indexed", "direct", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.clrsm), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_lnwdmd ( void )   /* line width specification mode */
+{
+ const char *options[] = { "abstract", "scaled", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.lnwsm), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_mkszmd ( void )   /* marker size specification mode */
+{
+ const char *options[] = { "abstract", "scaled", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.mkssm), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_edwdmd ( void )   /* edge width specification mode */
+{
+ const char *options[] = { "abstract", "scaled", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.edwsm), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_vdcext ( void )   /* vdc extent */
+{
+ if ( cgmt_p ( &(intcgm_cgm.vdc_ext.first.x), &(intcgm_cgm.vdc_ext.first.y) ) ) return 1;
+
+ if ( cgmt_p ( &(intcgm_cgm.vdc_ext.second.x), &(intcgm_cgm.vdc_ext.second.y) ) ) return 1;
+
+ if (cdcgmvdcextcb)
+  {
+   int err;
+   err = cdcgmvdcextcb( intcgm_canvas, intcgm_cgm.vdc_type, &(intcgm_cgm.vdc_ext.first.x), &(intcgm_cgm.vdc_ext.first.y),
+                                              &(intcgm_cgm.vdc_ext.second.x), &(intcgm_cgm.vdc_ext.second.y) );
+   if (err==CD_ABORT) return -1;
+  }
+
+ cgm_do_vdcext ( intcgm_cgm.vdc_ext.first, intcgm_cgm.vdc_ext.second );
+
+ return cgmt_ter();
+}
+
+int cgmt_bckcol ( void )   /* backgound colour */
+{
+ if ( cgmt_rgb ( &(intcgm_cgm.back_color.red), &(intcgm_cgm.back_color.green), &(intcgm_cgm.back_color.blue) ) ) return 1;
+
+ cgm_do_bckcol ( intcgm_cgm.back_color );
+
+ return cgmt_ter();
+}
+
+int cgmt_vdcipr ( void )   /* vdc integer precision */
+{
+ if ( cgmt_i ( &(intcgm_cgm.vdc_int.t_prec.minint) ) ) return 1;
+ if ( cgmt_i ( &(intcgm_cgm.vdc_int.t_prec.maxint) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_vdcrpr ( void )   /* vdc real precision */
+{
+ if ( cgmt_r ( &(intcgm_cgm.vdc_real.t_prec.minreal) ) ) return 1;
+ if ( cgmt_r ( &(intcgm_cgm.vdc_real.t_prec.maxreal) ) ) return 1;
+ if ( cgmt_i ( &(intcgm_cgm.vdc_real.t_prec.digits) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_auxcol ( void )   /* auxiliary colour */
+{
+ if ( cgmt_co ( &(intcgm_cgm.aux_color) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_transp ( void )   /* transparency */
+{
+ const char *options[] = { "on", "off", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.transparency), options ) ) return 1;
+
+ cgm_do_transp ( intcgm_cgm.transparency );
+
+ return cgmt_ter();
+}
+
+int cgmt_clprec ( void )   /* clip rectangle */
+{
+ if ( cgmt_p ( &(intcgm_cgm.clip_rect.first.x),  &(intcgm_cgm.clip_rect.first.y) ) ) return 1;
+
+ if ( cgmt_p ( &(intcgm_cgm.clip_rect.second.x),  &(intcgm_cgm.clip_rect.second.y) ) ) return 1;
+
+ cgm_do_clprec ( intcgm_cgm.clip_rect.first, intcgm_cgm.clip_rect.second );
+
+ return cgmt_ter();
+}
+
+int cgmt_clpind ( void )   /* clip indicator */
+{
+ const char *options[] = { "on", "off", NULL };
+
+ if ( cgmt_e ( &(intcgm_cgm.clip_ind), options ) ) return 1;
+
+ cgm_do_clpind ( intcgm_cgm.clip_ind );
+
+ return cgmt_ter();
+}
+
+static tpoint *get_points ( int *np )
+{
+ *np=0;
+
+ do
+  {
+   if ( cgmt_p ( &(intcgm_point_list[*np].x), &(intcgm_point_list[*np].y) ) ) return NULL;
+   ++(*np);
+   if ( *np==intcgm_npoints)
+     {
+      intcgm_npoints *= 2;
+      intcgm_point_list = (tpoint *) realloc ( intcgm_point_list, intcgm_npoints*sizeof(tpoint) );
+     }
+  } while ( cgmt_ter() );
+
+ return intcgm_point_list;
+}
+
+int cgmt_polyln ( void )   /* polyline */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_polyln ( np, pt );
+
+ return 0;
+}
+
+int cgmt_incply ( void )   /* incremental polyline */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_incply ( np, pt );
+
+ return 0;
+}
+
+int cgmt_djtply ( void )   /* disjoint polyline */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_djtply ( np, pt );
+
+ return 0;
+}
+
+int cgmt_indjpl ( void )   /* incremental disjoint polyline */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_indpl ( np, pt );
+
+ return 0;
+}
+
+int cgmt_polymk ( void )   /* polymarker */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_polymk ( np, pt );
+
+ return 0;
+}
+
+int cgmt_incplm ( void )   /* incremental polymarker */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_incplm ( np, pt );
+
+ return 0;
+}
+
+int cgmt_text ( void )   /* text */
+{
+ tpoint pos;
+ const char *options[] = { "final", "notfinal", NULL };
+ short flag;
+ char *string;
+
+ if ( cgmt_p ( &(pos.x), &(pos.y) ) ) return 1;
+
+ if ( cgmt_e ( &flag, options ) )  return 1;
+
+ if ( cgmt_s ( &string ) ) return 1;
+
+ cgm_do_text ( NORM_TEXT, string, pos );
+
+ free ( string );
+
+ return cgmt_ter();
+}
+
+int cgmt_rsttxt ( void )   /* restricted text */
+{
+ double width, height;
+ tpoint pos;
+ const char *options[] = { "final", "notfinal", NULL };
+ short flag;
+ char *string;
+
+ if ( cgmt_vdc ( &width ) ) return 1;
+
+ if ( cgmt_vdc ( &height ) ) return 1;
+
+ if ( cgmt_p ( &(pos.x), &(pos.y) ) ) return 1;
+
+ if ( cgmt_e ( &flag, options ) ) return 1;
+
+ if ( cgmt_s ( &string ) ) return 1;
+
+ intcgm_text_att.height = height;
+
+ cgm_do_text ( RESTRICTED_TEXT, string, pos );
+
+ if ( string!= NULL ) free ( string );
+
+ return cgmt_ter();
+}
+
+int cgmt_apdtxt ( void )   /* append text */
+{
+ const char *options[] = { "final", "notfinal", NULL };
+ short flag;
+ char *string;
+
+ if ( cgmt_e ( &flag, options ) ) return 1;
+
+ if ( cgmt_s ( &string ) ) return 1;
+
+ free ( string );
+
+ return cgmt_ter();
+}
+
+int cgmt_polygn ( void )   /* polygon */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_polygn ( np, pt );
+
+ return 0;
+}
+
+int cgmt_incplg ( void )   /* incremental polygon */
+{
+ tpoint *pt;
+ int np;
+
+ pt = get_points( &np );
+ if ( pt == NULL ) return 1;
+
+ cgm_do_incplg ( np, pt );
+
+ return 0;
+}
+
+static int get_point_set ( tpoint **pts, short **flags, int *np )
+{
+ int intcgm_block=500;
+ const char *options[] = { "invis", "vis", "closeinvis", "closevis", NULL };
+
+ *np=0;
+ *pts = (tpoint *) malloc ( intcgm_block*sizeof(tpoint) );
+ *flags = (short *) malloc ( intcgm_block*sizeof(short) );
+
+ do
+  {
+   if ( cgmt_p ( &((*pts)[*np].x), &((*pts)[*np].y) ) ) return 1;
+
+   if ( cgmt_e ( &((*flags)[*np]), options ) ) return 1;
+
+   ++(*np);
+   if ( *np==intcgm_block)
+    {
+     intcgm_block *= 2;
+     *pts = (tpoint *) realloc ( *pts, intcgm_block*sizeof(tpoint) );
+     *flags = (short *) realloc ( *flags, intcgm_block*sizeof(short) );
+    }
+  } while ( cgmt_ter() );
+
+ return 0;
+}
+
+int cgmt_plgset ( void )   /* polygon set */
+{
+ tpoint *pt;
+ short *flag;
+ int np;
+
+ if ( get_point_set ( &pt, &flag, &np ) ) return 1;
+
+ cgm_do_plgset( NO, np, pt, flag );
+
+ free ( pt );
+ free ( flag );
+
+ return 0;
+}
+
+int cgmt_inpgst ( void )   /* incremental polygon set */
+{
+ tpoint *pt;
+ short *flag;
+ int np;
+
+ if ( get_point_set ( &pt, &flag, &np ) ) return 1;
+
+ cgm_do_plgset( YES, np, pt, flag );
+
+ free ( pt );
+ free ( flag );
+
+ return 0;
+}
+
+int cgmt_cellar ( void )   /* cell array */
+{
+ tpoint corner1;
+ tpoint corner2;
+ tpoint corner3;
+ long nx, ny;
+ long local_color_prec;
+ tcolor *cell;
+ int i,k;
+
+ if ( cgmt_p ( &(corner1.x), &(corner1.y) ) ) return 1;
+ if ( cgmt_p ( &(corner2.x), &(corner2.y) ) ) return 1;
+ if ( cgmt_p ( &(corner3.x), &(corner3.y) ) ) return 1;
+
+ if ( cgmt_i ( &nx ) ) return 1;
+ if ( cgmt_i ( &ny ) ) return 1;
+
+ if ( cgmt_i ( &(local_color_prec) ) ) return 1;
+
+ cell = (tcolor *) malloc ( nx*ny*sizeof(tcolor) );
+ 
+ cgmt_getparentheses();
+
+  for ( k=0; k<ny; k++ )
+   {
+    for ( i=0; i<nx; i++ )
+     {
+      if ( cgmt_co ( &(cell[k*nx+i]) ) ) return 1;
+	   }
+    cgm_getfilepos();
+   }
+
+ cgmt_getparentheses();
+
+ cgm_do_cellar ( corner1, corner2, corner3, nx, ny, local_color_prec, cell );
+
+ free(cell);
+
+ return cgmt_ter();
+}
+
+int cgmt_gdp ( void )   /* generalized drawing picture */
+{
+ long identifier;
+ tpoint *pt = NULL;
+ int intcgm_block = 500;
+ int np = 0;
+ char *data_rec;
+
+ pt = (tpoint *) malloc ( intcgm_block*sizeof(tpoint) );
+
+ if ( cgmt_i ( &identifier ) ) return 1;
+
+ while ( strstr(cgmt_getsep(),",")==NULL )
+  {
+   if ( cgmt_p ( &(pt[np].x), &(pt[np].y) ) )
+    {
+	 if ( pt!=NULL ) free(pt);
+     return 1;
+	}
+   ++np;
+
+   if ( np==intcgm_block )
+    {
+     intcgm_block *= 2;
+     pt = (tpoint *) realloc ( pt, intcgm_block*sizeof(tpoint) );
+    }
+  }
+
+ if ( cgmt_s ( &data_rec ) ) return 1;
+
+ cgm_do_gdp ( identifier, pt, data_rec );
+
+ free ( data_rec );
+ free ( pt );
+
+ return cgmt_ter();
+}
+
+int cgmt_rect ( void )   /* rectangle */
+{
+ tpoint point1;
+ tpoint point2;
+
+ if ( cgmt_p ( &(point1.x), &(point1.y) ) ) return 1;
+ if ( cgmt_p ( &(point2.x), &(point2.y) ) ) return 1;
+
+ cgm_do_rect ( point1, point2 );
+
+ return cgmt_ter();
+}
+
+int cgmt_circle ( void )   /* circle */
+{
+ tpoint center;
+ double radius;
+
+ if ( cgmt_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &radius ) ) return 1;
+
+ cgm_do_circle ( center, radius );
+
+ return cgmt_ter();
+}
+
+int cgmt_circ3p ( void )   /* circular arc 3 point */
+{
+ tpoint starting;
+ tpoint intermediate;
+ tpoint ending;
+
+ if ( cgmt_p ( &(starting.x), &(starting.y) ) ) return 1;
+ if ( cgmt_p ( &(intermediate.x), &(intermediate.y) ) ) return 1;
+ if ( cgmt_p ( &(ending.x), &(ending.y) ) ) return 1;
+
+ cgm_do_circ3p ( starting, intermediate, ending );
+
+ return cgmt_ter();
+}
+
+int cgmt_cir3pc ( void )  /* circular arc 3 point close */
+{
+ tpoint starting;
+ tpoint intermediate;
+ tpoint ending;
+ const char *options[] = { "pie", "chord", NULL };
+ short close_type;
+
+ if ( cgmt_p ( &(starting.x), &(starting.y) ) ) return 1;
+ if ( cgmt_p ( &(intermediate.x), &(intermediate.y) ) ) return 1;
+ if ( cgmt_p ( &(ending.x), &(ending.y) ) ) return 1;
+
+ if ( cgmt_e ( &close_type, options ) ) return 1;
+
+ cgm_do_circ3pc ( starting, intermediate, ending, close_type );
+
+ return cgmt_ter();
+}
+
+int cgmt_circnt ( void )   /* circular arc centre */
+{
+ tpoint center;
+ tpoint start;
+ tpoint end;
+ double  radius;
+
+ if ( cgmt_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(start.x) ) ) return 1;
+ if ( cgmt_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(end.x) ) ) return 1;
+ if ( cgmt_vdc ( &(end.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &radius ) ) return 1;
+
+ cgm_do_circcnt ( center, start, end, radius );
+
+ return cgmt_ter();
+}
+
+int cgmt_ccntcl ( void )   /* circular arc centre close */
+{
+ tpoint center;
+ tpoint start;
+ tpoint end;
+ double radius;
+ const char *options[] = { "pie", "chord", NULL };
+ short close_type;
+
+ if ( cgmt_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(start.x) ) ) return 1;
+ if ( cgmt_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(end.x) ) ) return 1;
+ if ( cgmt_vdc ( &(end.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &radius ) ) return 1;
+
+ if ( cgmt_e ( &close_type, options ) ) return 1;
+
+ cgm_do_ccntcl ( center, start, end, radius, close_type );
+
+ return cgmt_ter();
+}
+
+int cgmt_ellips ( void )   /* ellipse */
+{
+ tpoint center;
+ tpoint first_CDP;
+ tpoint second_CDP;
+
+ if ( cgmt_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmt_p ( &(first_CDP.x), &(first_CDP.y) ) ) return 1;
+ if ( cgmt_p ( &(second_CDP.x), &(second_CDP.y) ) ) return 1;
+
+ cgm_do_ellips ( center, first_CDP, second_CDP );
+
+ return cgmt_ter();
+}
+
+int cgmt_ellarc ( void )   /* elliptical arc */
+{
+ tpoint center;
+ tpoint first_CDP;
+ tpoint second_CDP;
+ tpoint start, end;
+
+ if ( cgmt_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmt_p ( &(first_CDP.x), &(first_CDP.y) ) ) return 1;
+ if ( cgmt_p ( &(second_CDP.x), &(second_CDP.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(start.x) ) ) return 1;
+ if ( cgmt_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(end.x) ) ) return 1;
+ if ( cgmt_vdc ( &(end.y) ) ) return 1;
+
+ cgm_do_ellarc ( center, first_CDP, second_CDP, start, end );
+
+ return cgmt_ter();
+}
+
+int cgmt_ellacl ( void )   /* elliptical arc close */
+{
+ tpoint center;
+ tpoint first_CDP;
+ tpoint second_CDP;
+ tpoint start, end;
+ const char *options[] = { "pie", "chord", NULL };
+ short close_type;
+
+ if ( cgmt_p ( &(center.x), &(center.y) ) ) return 1;
+
+ if ( cgmt_p ( &(first_CDP.x), &(first_CDP.y) ) ) return 1;
+ if ( cgmt_p ( &(second_CDP.x), &(second_CDP.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(start.x) ) ) return 1;
+ if ( cgmt_vdc ( &(start.y) ) ) return 1;
+
+ if ( cgmt_vdc ( &(end.x) ) ) return 1;
+ if ( cgmt_vdc ( &(end.y) ) ) return 1;
+
+ if ( cgmt_e ( &close_type, options ) ) return 1;
+
+ cgm_do_ellacl ( center, first_CDP, second_CDP, start, end, close_type );
+
+ return cgmt_ter();
+}
+
+int cgmt_lnbdin ( void )   /* line bundle index */
+{
+ if ( cgmt_i ( &(intcgm_line_att.index) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_lntype ( void )   /* line type */
+{
+ if ( cgmt_i ( &(intcgm_line_att.type) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_lnwidt ( void )  /* line width */
+{
+ if ( intcgm_cgm.lnwsm==0 )
+  {
+   if ( cgmt_vdc ( &(intcgm_line_att.width) ) ) return 1;
+  }
+ else
+  {
+
+   if ( cgmt_r ( &(intcgm_line_att.width) ) ) return 1;
+  }
+
+ return cgmt_ter();
+}
+
+int cgmt_lncolr ( void )   /* line colour */
+{
+ if ( cgmt_co ( &(intcgm_line_att.color) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_mkbdin ( void )   /* marker bundle index */
+{
+ if ( cgmt_i ( &(intcgm_marker_att.index) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_mktype ( void )   /* marker type */
+{
+ if ( cgmt_i ( &(intcgm_marker_att.type) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_mksize ( void )   /* marker size */
+{
+ if ( intcgm_cgm.mkssm == 0 )
+  {
+   if ( cgmt_vdc ( &(intcgm_marker_att.size) ) ) return 1;
+  }
+ else
+  {
+   if ( cgmt_r ( &(intcgm_marker_att.size) ) ) return 1;
+  }
+
+ return cgmt_ter();
+}
+
+int cgmt_mkcolr ( void )   /* marker colour */
+{
+ if ( cgmt_co ( &(intcgm_marker_att.color) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_txbdin ( void )   /* text bundle index */
+{
+ if ( cgmt_i ( &(intcgm_text_att.index) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_txftin ( void )   /* text font index */
+{
+ char *font;
+ char *font_array[] = {"SYSTEM", "COURIER", "TIMES", "HELVETICA", NULL};
+ char *style_array[] = {"BOLDITALIC", "ITALIC", "BOLD", "PLAIN", NULL};
+ int cdstyle[] = {CD_BOLD_ITALIC, CD_ITALIC, CD_BOLD, CD_PLAIN};
+ int i;
+
+ if ( cgmt_i ( &(intcgm_text_att.font_index) ) ) return 1;
+
+ font = (char *) cgm_GetList ( intcgm_text_att.font_list, intcgm_text_att.font_index );
+
+ if ( font==NULL ) font = (char*)strdup ( "SYSTEM" );
+
+ intcgm_text_att.font = 0;
+ for ( i=0; font_array[i]!=NULL; i++ )
+  {
+   if ( strstr( font, font_array[i] ) )
+    {
+     intcgm_text_att.font = i;
+     break;
+    }
+  }
+
+ intcgm_text_att.style = 0;
+ for ( i=0; style_array[i]!=NULL; i++ )
+  {
+   if ( strstr( font, style_array[i] ) )
+    {
+     intcgm_text_att.style = cdstyle[i];
+     break;
+    }
+  }
+
+ cgm_setfont ( intcgm_text_att.font, intcgm_text_att.style, intcgm_text_att.height );
+
+ return cgmt_ter();
+}
+
+int cgmt_txtprc ( void )   /* text precision */
+{
+ const char *options[] = { "string", "char", "stroke", NULL };
+
+ if ( cgmt_e ( &(intcgm_text_att.prec), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_chrexp ( void )   /* char expansion factor */
+{
+ if ( cgmt_r ( &(intcgm_text_att.exp_fact) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_chrspc ( void )   /* char spacing */
+{
+ if ( cgmt_r ( &(intcgm_text_att.char_spacing) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_txtclr ( void )   /* text colour */
+{
+ if ( cgmt_co ( &(intcgm_text_att.color) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_chrhgt ( void )   /* char height */
+{
+ if ( cgmt_vdc ( &(intcgm_text_att.height) ) ) return 1;
+
+ cgm_do_text_height ( intcgm_text_att.height );
+
+ return cgmt_ter();
+}
+
+int cgmt_chrori ( void )   /* char orientation */
+{
+ if ( cgmt_vdc ( &(intcgm_text_att.char_up.x) ) ) return 1;
+ if ( cgmt_vdc ( &(intcgm_text_att.char_up.y) ) ) return 1;
+ if ( cgmt_vdc ( &(intcgm_text_att.char_base.x) ) ) return 1;
+ if ( cgmt_vdc ( &(intcgm_text_att.char_base.y) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_txtpat ( void )   /* text path */
+{
+ const char *options[] = { "right", "left", "up", "down", NULL };
+
+ if ( cgmt_e ( &(intcgm_text_att.path), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_txtali ( void )   /* text alignment */
+{
+ const char *hor[] = { "normhoriz", "left", "ctr", "right", "conthoriz", NULL };
+ const char *ver[] = { "normvert", "top", "cap", "half", "base", "bottom",
+                       "contvert", NULL };
+
+ if ( cgmt_e ( &(intcgm_text_att.alignment.hor), hor ) ) return 1;
+ if ( cgmt_e ( &(intcgm_text_att.alignment.ver), ver ) ) return 1;
+
+ if ( cgmt_r ( &(intcgm_text_att.alignment.cont_hor) ) ) return 1;
+ if ( cgmt_r ( &(intcgm_text_att.alignment.cont_ver) ) ) return 1;
+
+ cgm_do_txtalign ( intcgm_text_att.alignment.hor, intcgm_text_att.alignment.ver );
+
+ return cgmt_ter();
+}
+
+int cgmt_chseti ( void )   /* character set index */
+{
+ long set;
+
+ if ( cgmt_i ( &set ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_achsti ( void )   /* alternate character set index */
+{
+ long set;
+
+ if ( cgmt_i ( &set ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_fillin ( void )   /* fill bundle index */
+{
+ if ( cgmt_i ( &(intcgm_fill_att.index) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_intsty ( void )   /* interior style */
+{
+ const char *options[] = { "hollow", "solid", "pat", "hatch", "empty", NULL };
+
+ if ( cgmt_e ( &(intcgm_fill_att.int_style), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_fillco ( void )   /* fill colour */
+{
+ if ( cgmt_co ( &(intcgm_fill_att.color) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_hatind ( void )   /* hatch index */
+{
+ if ( cgmt_i ( &(intcgm_fill_att.hatch_index) ) ) return 1;
+ if ( intcgm_fill_att.hatch_index==3 ) intcgm_fill_att.hatch_index = 4;
+ else if ( intcgm_fill_att.hatch_index==4 ) intcgm_fill_att.hatch_index = 3;
+
+ return cgmt_ter();
+}
+
+int cgmt_patind ( void )   /* pattern index */
+{
+ if ( cgmt_i ( &(intcgm_fill_att.pat_index) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_edgind ( void )   /* edge bundle index */
+{
+ if ( cgmt_i ( &(intcgm_edge_att.index) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_edgtyp( void )   /* edge type */
+{
+ if ( cgmt_i ( &(intcgm_edge_att.type) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_edgwid ( void )   /* edge width */
+{
+ if ( intcgm_cgm.edwsm==0 )
+  {
+   if ( cgmt_vdc ( &(intcgm_edge_att.width) ) ) return 1;
+  }
+ else
+  {
+   if ( cgmt_r ( &(intcgm_edge_att.width) ) ) return 1;
+  }
+
+ return cgmt_ter();
+}
+
+int cgmt_edgcol ( void )   /* edge colour */
+{
+ if ( cgmt_co ( &(intcgm_edge_att.color) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_edgvis ( void )   /* edge visibility */
+{
+ const char *options[] = { "off", "on", NULL };
+
+ if ( cgmt_e ( &(intcgm_edge_att.visibility), options ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_fillrf ( void )   /* fill reference point */
+{
+ if ( cgmt_p ( &(intcgm_fill_att.ref_pt.x),  &(intcgm_fill_att.ref_pt.y) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_pattab ( void )   /* pattern table */
+{
+ long local_color_prec;
+ int i;
+ pat_table *pat, *p;
+
+ pat = (pat_table *) malloc ( sizeof(pat_table) );
+
+ if ( intcgm_fill_att.pat_list==NULL ) intcgm_fill_att.pat_list = cgm_NewList();
+
+ if ( cgmt_i ( &(pat->index) ) ) return 1;
+
+ if ( cgmt_i ( &(pat->nx) ) ) return 1;
+ if ( cgmt_i ( &(pat->ny) ) ) return 1;
+
+ if ( cgmt_i ( &(local_color_prec) ) ) return 1;
+
+ pat->pattern = (tcolor *) malloc ( pat->nx*pat->ny*sizeof(tcolor) );
+
+ cgmt_getparentheses();
+
+ for ( i=0; i<(pat->nx*pat->ny); i++ )
+   if ( cgmt_co ( &(pat->pattern[i]) ) ) return 1;
+
+ cgmt_getparentheses();
+
+ for ( i=0; (p=(pat_table *)cgm_GetList(intcgm_fill_att.pat_list,i))!=NULL; i++ )
+  {
+   if ( p->index==pat->index )
+    {
+     free(p->pattern);
+     cgm_DelList(intcgm_fill_att.pat_list,i);
+     break;
+    }
+  }
+
+ cgm_AppendList ( intcgm_fill_att.pat_list, pat );
+
+ return cgmt_ter();
+}
+
+int cgmt_patsiz ( void )   /* pattern size */
+{
+ if ( cgmt_vdc ( &(intcgm_fill_att.pat_size.height.x) ) ) return 1;
+ if ( cgmt_vdc ( &(intcgm_fill_att.pat_size.height.y) ) ) return 1;
+ if ( cgmt_vdc ( &(intcgm_fill_att.pat_size.width.x) ) ) return 1;
+ if ( cgmt_vdc ( &(intcgm_fill_att.pat_size.width.y) ) ) return 1;
+
+ return cgmt_ter();
+}
+
+int cgmt_coltab ( void )   /* colour table */
+{
+ long starting_index;
+
+ if ( cgmt_i ( &(starting_index) ) ) return 1;
+
+ while ( cgmt_ter() )
+  {
+   if ( cgmt_rgb ( &(intcgm_color_table[starting_index].red), &(intcgm_color_table[starting_index].green),
+                   &(intcgm_color_table[starting_index].blue) ) ) return 1;
+   starting_index++;
+  }
+
+ return 0;
+}
+
+int cgmt_asf ( void )   /* asfs */
+{
+ const char *asf_value[] = { "bundled", "indiv", NULL };
+ const char *asf_type[] = { "linetype"     , "linewidth" , "linecolr"  ,
+                            "markertype"   , "markersize", "markercolr",
+                            "textfontindex", "textprec"  , "charexp"   ,
+                            "charspace"    , "textcolr"  , "intstyle"  ,
+                            "fillcolr"     , "hatchindex", "patindex"  ,
+                            "edgetype"     , "edgewidth" , "edgecolr"  ,
+                            "all"          , "allline"   , "allmarker" ,
+                            "alltext"      , "allfill"   , "alledge", NULL };
+ tasf *pair;
+
+ if ( intcgm_asf_list==NULL ) intcgm_asf_list = cgm_NewList();
+
+ while( cgmt_ter() )
+  {
+   pair = (tasf *) malloc ( sizeof (tasf) );
+
+   if ( cgmt_e ( &(pair->type), asf_type ) ) return 1;
+   if ( cgmt_e ( &(pair->value), asf_value ) ) return 1;
+
+   cgm_AppendList ( intcgm_asf_list, pair );
+  }
+
+ return 0;
+}
+
+int cgmt_escape ( void )   /* escape */
+{
+ long identifier;
+ char *data_rec;
+
+ if ( cgmt_i ( &(identifier) ) ) return 1;
+
+ if ( cgmt_s ( &data_rec ) ) return 1;
+
+ free(data_rec);
+                  
+ return cgmt_ter();
+}
+
+int cgmt_messag ( void )   /* message */
+{
+ const char *options[] = { "noaction", "action", NULL };
+ char *text;
+ short flag;
+
+ if ( cgmt_e ( &flag, options ) ) return 1;
+
+ if ( cgmt_s ( &text ) ) return 1;
+
+ free(text);
+
+ return cgmt_ter();
+}
+
+int cgmt_appdta ( void )   /* application data */
+{
+ long identifier;
+ char *data_rec;
+
+ if ( cgmt_i ( &identifier ) ) return 1;
+
+ if ( cgmt_s ( &data_rec ) ) return 1;
+
+ free(data_rec);
+
+ return cgmt_ter();
+}
diff --git a/src/intcgm/tparse.h b/src/intcgm/tparse.h
new file mode 100644
index 0000000..c1292bc
--- /dev/null
+++ b/src/intcgm/tparse.h
@@ -0,0 +1,101 @@
+#ifndef _TPARSE_H_
+#define _TPARSE_H_
+
+int cgmt_begmtf ( void );
+int cgmt_endmtf ( void );
+int cgmt_begpic ( void );
+int cgmt_begpib ( void );
+int cgmt_endpic ( void );
+int cgmt_mtfver ( void );
+int cgmt_mtfdsc ( void );
+int cgmt_vdctyp ( void );
+int cgmt_intpre ( void );
+int cgmt_realpr ( void );
+int cgmt_indpre ( void );
+int cgmt_colpre ( void );
+int cgmt_colipr ( void );
+int cgmt_maxcoi ( void );
+int cgmt_covaex ( void );
+int cgmt_mtfell ( void );
+int cgmt_bmtfdf (void );
+int cgmt_emtfdf ( void );
+int cgmt_fntlst ( void );
+int cgmt_chslst ( void );
+int cgmt_chcdac ( void );
+int cgmt_sclmde ( void );
+int cgmt_clslmd ( void );
+int cgmt_lnwdmd ( void );
+int cgmt_mkszmd ( void );
+int cgmt_edwdmd ( void );
+int cgmt_vdcext ( void );
+int cgmt_bckcol ( void );
+int cgmt_vdcipr ( void );
+int cgmt_vdcrpr ( void );
+int cgmt_auxcol ( void );
+int cgmt_transp ( void );
+int cgmt_clprec ( void );
+int cgmt_clpind ( void );
+int cgmt_polyln ( void );
+int cgmt_incply ( void );
+int cgmt_djtply ( void );
+int cgmt_indjpl ( void );
+int cgmt_polymk ( void );
+int cgmt_incplm ( void );
+int cgmt_text ( void );
+int cgmt_rsttxt ( void );
+int cgmt_apdtxt ( void );
+int cgmt_polygn ( void );
+int cgmt_incplg ( void );
+int cgmt_plgset ( void );
+int cgmt_inpgst ( void );
+int cgmt_cellar ( void );
+int cgmt_gdp ( void );
+int cgmt_rect ( void );
+int cgmt_circle ( void );
+int cgmt_circ3p ( void );
+int cgmt_cir3pc ( void );
+int cgmt_circnt ( void );
+int cgmt_ccntcl ( void );
+int cgmt_ellips ( void );
+int cgmt_ellarc ( void );
+int cgmt_ellacl ( void );
+int cgmt_lnbdin ( void );
+int cgmt_lntype ( void );
+int cgmt_lnwidt ( void );
+int cgmt_lncolr ( void );
+int cgmt_mkbdin ( void );
+int cgmt_mktype ( void );
+int cgmt_mksize ( void );
+int cgmt_mkcolr ( void );
+int cgmt_txbdin ( void );
+int cgmt_txftin ( void );
+int cgmt_txtprc ( void );
+int cgmt_chrexp ( void );
+int cgmt_chrspc ( void );
+int cgmt_txtclr ( void );
+int cgmt_chrhgt ( void );
+int cgmt_chrori ( void );
+int cgmt_txtpat ( void );
+int cgmt_txtali ( void );
+int cgmt_chseti ( void );
+int cgmt_achsti ( void );
+int cgmt_fillin ( void );
+int cgmt_intsty ( void );
+int cgmt_fillco ( void );
+int cgmt_hatind ( void );
+int cgmt_patind ( void );
+int cgmt_edgind ( void );
+int cgmt_edgtyp( void );
+int cgmt_edgwid ( void );
+int cgmt_edgcol ( void );
+int cgmt_edgvis ( void );
+int cgmt_fillrf ( void );
+int cgmt_pattab ( void );
+int cgmt_patsiz ( void );
+int cgmt_coltab ( void );
+int cgmt_asf ( void );
+int cgmt_escape ( void );
+int cgmt_messag ( void );
+int cgmt_appdta ( void );
+
+#endif
diff --git a/src/intcgm/types.h b/src/intcgm/types.h
new file mode 100644
index 0000000..6d6f65c
--- /dev/null
+++ b/src/intcgm/types.h
@@ -0,0 +1,225 @@
+#ifndef _CGM_TYPES_H_
+#define _CGM_TYPES_H_
+
+typedef struct { 
+                double xmin;
+                double xmax;
+                double ymin;
+                double ymax;
+               } tlimit;
+
+typedef struct {
+                unsigned long red;
+                unsigned long green;
+                unsigned long blue;
+               } trgb;
+
+typedef union {
+               int ind;
+               trgb rgb;
+              } tcolor;
+
+typedef struct {
+                double x;
+                double y;
+               } tpoint;
+
+typedef struct {
+                char *dados;
+                int size;
+               } tdados;
+
+typedef struct {
+                FILE *fp;
+
+		int (*cgmf)(void);
+
+		int file_size;
+		
+		int first;
+
+        int mode;      /* character, binary, clear text */
+
+		int len;
+
+		tdados buff;
+
+                short vdc_type;
+
+                union  {
+                        long   b_prec;  /* 8, 16, 24, 32 */
+		        struct { long minint; long maxint; } t_prec ;
+                       } int_prec;
+                union {
+                       long   b_prec; /* float*32, float*64, fixed*32, fixed*64 */
+		       struct { double minreal; double maxreal; long digits; } t_prec;
+                      } real_prec;
+                union {
+                       long   b_prec;  /* 8, 16, 24, 32 */
+		       struct { long minint; long maxint; } t_prec;
+                      } ix_prec;
+                long cd_prec;
+                long cix_prec;
+                struct {
+                        trgb black;
+                        trgb white;
+                       } color_ext;
+                long max_cix;
+
+                struct {
+                        short mode;
+                        double scale_factor;
+                       } scaling_mode;
+
+                short drawing_mode;
+
+                short clrsm;
+                short lnwsm;
+                short mkssm;
+                short edwsm;
+
+                union {
+                       long   b_prec;  /* 8, 16, 24, 32 */
+		       struct { long minint; long maxint; } t_prec;
+                      } vdc_int;
+                union {
+                       long   b_prec; /* float*32, float*64, fixed*32, fixed*64 */
+		       struct { double minreal; double maxreal; long digits; } t_prec;
+                      } vdc_real;
+
+                struct {
+                        tpoint first;
+                        tpoint second;
+                       } vdc_ext;
+
+                trgb back_color;
+
+                tcolor aux_color;
+
+                short transparency;
+
+                struct {
+                        tpoint first;
+                        tpoint second;
+                       } clip_rect;
+
+                short clip_ind;
+
+                int            bc;        /* byte count */
+                int            pc;        /* pixel count */
+
+                long           bl;        /* bytes lidos */
+
+                int            cl;        /* coluna para alinhamento */
+
+               } t_cgm;
+
+typedef struct {
+                long index;
+                long type;
+                double width;
+                tcolor color;
+               } _line_att;
+
+typedef struct {
+                long index;
+                long type;
+                double size;
+                tcolor color;
+               } _marker_att;
+
+typedef struct {
+                long index;
+                long font_index;
+				TList *font_list;
+				int font;
+				int style;
+				int size;
+                short prec;
+                double exp_fact;
+                double char_spacing;
+                tcolor color;
+                double height;
+                tpoint char_up;
+                tpoint char_base;
+                short path;
+                struct { short hor;
+                         short ver;
+                         double cont_hor;
+                         double cont_ver;
+                       } alignment;
+               } _text_att;
+
+typedef struct {
+                long index;
+                short int_style;
+                tcolor color;
+                long hatch_index;
+                long pat_index;
+                tpoint ref_pt;
+                TList *pat_list;
+                struct {
+                        tpoint height;
+                        tpoint width;
+                       } pat_size;
+               } _fill_att;
+
+typedef struct {
+                long index;
+                long type;
+                double width;
+                tcolor color;
+                short visibility;
+               } _edge_att;
+
+enum { OFF, ON };
+
+enum { YES, NO };
+
+enum { INTEGER, REAL };
+
+enum { STRING, CHAR, STROKE };
+
+enum { ABSOLUTE, SCALED };
+
+enum { ABSTRACT, METRIC };
+
+enum { INDEXED, DIRECT };
+
+enum { MARK_DOT=1, MARK_PLUS=2, MARK_ASTERISK=3, MARK_CIRCLE=4, MARK_CROSS=5 };
+
+enum { LINE_SOLID=1, LINE_DASH=2, LINE_DOT=3, LINE_DASH_DOT=4,
+       LINE_DASH_DOT_DOT=5 };
+
+enum { EDGE_SOLID=1, EDGE_DASH=2, EDGE_DOT=3, EDGE_DASH_DOT=4,
+       EDGE_DASH_DOT_DOT=5 };
+
+enum { HOLLOW, SOLID, PATTERN, HATCH, EMPTY };
+
+enum { HORIZONTAL=1, VERTICAL=2, POSITIVE_SLOPE=3, NEGATIVE_SLOPE=4,
+       HV_CROSS=5, SLOPE_CROSS=6 };
+
+enum { PATH_RIGHT, PATH_LEFT, PATH_UP, PATH_DOWN };
+
+enum { NORMHORIZ, LEFT, CTR, RIGHT, CONTHORIZ };
+
+enum { NORMVERT, TOP, CAP, HALF, BASE, BOTTOM, CONTVERT };
+
+enum { LINE_TYPE, LINE_WIDTH, LINE_COLOUR, MARKER_TYPE, MARKER_SIZE,
+       MARKER_COLOUR, TEXT_FONT_INDEX, TEXT_PRECISION,
+       CHARACTER_EXPANSION_FACTOR, CHARACTER_SPACING, TEXT_COLOUR,
+       INTERIOR_STYLE, FILL_COLOUR, HATCH_INDEX, PATTERN_INDEX, EDGE_TYPE,
+       EDGE_WIDTH, EDGE_COLOUR, ALL, ALL_LINE, ALL_MARKER, ALL_TEXT, ALL_FILL,
+       ALL_EDGE };
+
+enum { INDIVIDUAL, BUNDLED };
+
+enum { INVISIBLE, VISIBLE, CLOSE_INVISIBLE, CLOSE_VISIBLE };
+
+enum { PIE, CHORD };
+
+enum { OPEN, CLOSED_PIE, CLOSED_CHORD };
+
+enum { NORM_TEXT, RESTRICTED_TEXT };
+
+#endif