/* Standard include files */ #include "cgmout.h" #include "cgminit.h" /* Output stream for functions */ static FILE *cgmot; /* Functions in this Module */ # if (defined __STDC__ && __STDC__) || defined __cplusplus /* use function prototypes, they are requred for ANSI C and C++ compilers */ void CGMOtext(FILE *stream, Code c, Long *pi, float *pr, char *str); /* Main Output */ static void MOTpoints(Long n, Long *pi, float *pr, Enum set), /* Output a points list */ MOTvdc(int n, Long *pi, Float *pr), /* Output n VDCs */ MOTcol(struct colour *c, Enum type), /* Output a colour */ MOTstring(char *s), /* Output a text string */ MOTenum(char *s, Enum k), /* Output an enumerated type */ MOTprcode(Code code); /* Output a metafile element code */ #else void CGMOtext(); /* Main Output */ static void MOTpoints(), /* Output a points list */ MOTvdc(), /* Output n VDCs */ MOTcol(), /* Output a colour */ MOTstring(), /* Output a text string */ MOTenum(), /* Output an enumerated type */ MOTprcode(); /* Output a metafile element code */ #endif /* Local macro */ #define TEXTOUT (void) fprintf( cgmot, /* Table for element decoding */ extern const struct commands cgmelement[]; /* Local Variables */ static int vp = 4, rp = 4; /* decimal places for real numbers */ static int indent; /* Indent for current element */ #include "cgmatt.h" /*static char *func = "CGMotext", mess[40];*/ static char mess[40]; /****************************************************** CGMOtext *******/ void CGMOtext(FILE *stream, Code c, Long *pi, float *pr, char *str) { /* Outputs Clear Text for MF element 'c' on Output stream 'stream' */ static Logical first = TRUE, first_pic = TRUE; static Prec loc_prec; static Long nx, ny; register Long n, i, j, k, num; Code major; Posint prec; /* char s[100];*/ if (c == (Code) EOF) { exit(0); } cgmot = stream; major = c>>8; num = *pi++; switch (major) { case 0x00: /* Graphics Primitives */ switch (c) { case NONOP: /* Ignore Non-Op */ break; case LINE: /* Polyline */ if ( first ) MOTprcode ( LINE ); MOTpoints ( num, pi, pr, NOSET); first = ( num >= ZERO ); break; case DISJTLINE: /* Disjoint Polyline */ if ( first ) MOTprcode ( DISJTLINE ); MOTpoints ( num, pi, pr, NOSET); first = ( num >= ZERO ); break; case MARKER: /* Polymarker */ if ( first ) MOTprcode ( MARKER ); MOTpoints ( num, pi, pr, NOSET); first = ( num >= ZERO ); break; case TEXT: /* Text */ MOTprcode ( TEXT ); MOTpoints ((Long)1, pi, pr, NOSET); MOTenum("notfinal/final", (Enum) num); MOTstring ( str ); break; case RESTRTEXT: /* Restricted Text */ MOTprcode ( RESTRTEXT ); MOTvdc ((Int)2, pi, pr); MOTpoints ((Long)1, pi+2, pr+2, NOSET); MOTenum("notfinal/final", (Enum) num); MOTstring ( str ); break; case APNDTEXT: /* Append Text */ MOTprcode ( APNDTEXT ); MOTenum("notfinal/final", (Enum) num); MOTstring ( str ); break; case POLYGON: /* Polygon */ if ( first ) MOTprcode ( POLYGON ); MOTpoints ( num, pi, pr, NOSET); first = ( num >= ZERO ); break; case POLYGONSET: /* Polygon Set */ if ( first ) MOTprcode ( POLYGONSET ); MOTpoints ( num, pi, pr, SET); first = ( num >= ZERO ); break; case CELLARRAY: /* Cell Array */ if ( first ) { MOTprcode ( CELLARRAY ); MOTpoints ((Long)3, pi, pr, NOSET); pi += 6; nx = *pi++; ny = *pi++; loc_prec = *pi++; k = ( loc_prec ? ( 1L<= ZERO ); if ( ! first ) num = -num; /* set decimal places and number of elements per line 'k' */ prec = (Prec)((loc_prec ? (Double)loc_prec : (Double)cur.col_bits )*LOG2) + 1; if ( prec < 2 ) prec = 2; if ( cur.color_mode == INDEXED ) k = 80L / (prec+1); else k = 80L / (3*prec+5); if ( k > nx ) k = nx; n = nx; i = k; for ( j = ZERO; j < num ; j++ ) { if ( j ) /* Check for line skip after first pass */ { if ( cur.color_mode == DIRECT ) TEXTOUT ","); /* Line skip if end of row or row count reached */ if ( j == n || j == i ) { TEXTOUT "\n"); if ( j == n ) { n += nx; i = j + k; /* Extra line skip if row is Longer than one line */ if ( nx > k ) TEXTOUT "\n"); } else i += k; } else TEXTOUT " "); } if ( cur.color_mode == INDEXED ) TEXTOUT "%*ld", (int)prec, *pi++); else { TEXTOUT "%*ld %*ld %*ld", (int)prec, *pi, (int)prec, *(pi+1), (int)prec, *(pi+2)); pi += (Long)3; } } if ( ! first ) /* Not finished yet */ { TEXTOUT "\n"); if ( nx > k ) TEXTOUT "\n"); } break; case GDP: /* Generalised Drawing Primitive */ MOTprcode ( GDP ); TEXTOUT " %ld ", *pi++); MOTpoints (num, pi, pr, ZERO); MOTstring ( str ); break; case RECT: /* Rectangle */ MOTprcode ( RECT ); MOTpoints ((Long)2, pi, pr, ZERO); break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } break; case 0x30: /* Delimiter Elements */ switch (c) { case BEGMF: /* Begin Metafile */ MOTprcode ( BEGMF ); MOTstring ( str ); curtext = textdef; break; case ENDMF: /* End Metafile */ MOTprcode ( ENDMF ); break; case BEGPIC: /* Begin Picture Descriptor */ TEXTOUT "\n"); MOTprcode ( BEGPIC ); if ( first_pic ) { first_pic = FALSE; mftext = curtext; /* Set MF defaults */ } else curtext = mftext; /* Set Text picture defaults */ TEXTOUT "'Picture Number "); TEXTOUT "%ld'",*pi); break; case BEGPICBODY: /* Begin Picture Body */ MOTprcode ( BEGPICBODY ); break; case ENDPIC: /* End Picture */ MOTprcode ( ENDPIC ); break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } case 0x31: /* Metafile Descriptor Elements */ switch (c) { case MFVERSION: /* Metafile version */ MOTprcode ( MFVERSION ); TEXTOUT " %ld", num); break; case MFDESC: /* Metafile Description */ MOTprcode ( MFDESC ); MOTstring ( str ); break; case VDCTYPE: /* VDC Type */ MOTprcode ( VDCTYPE ); MOTenum ("integer/real",cur.vdc_type); break; case INTEGERPREC: /* Integer Precision */ MOTprcode ( INTEGERPREC ); curtext.max_int = (Long) (1L<< (cur.int_bits - 1)) -1; curtext.min_int = - curtext.max_int - 1; TEXTOUT " %ld, %ld", curtext.min_int, curtext.max_int); break; case REALPREC: /* Real Precision */ MOTprcode ( REALPREC ); curtext.max_real = cur.max_real; curtext.min_real = cur.min_real; curtext.real_digits = (long)(1.0 + (cur.real_bits - cur.real_places) * LOG2); rp =4; TEXTOUT " %.*f, %.*f,", rp, (Double)curtext.min_real, rp,(Double)curtext.max_real); TEXTOUT " %ld", curtext.real_digits); break; case INDEXPREC: /* Index Precision */ MOTprcode ( INDEXPREC ); curtext.max_index = (Long) (1L<<(cur.index_bits - 1)) -1; curtext.min_index = -curtext.max_index - 1; TEXTOUT " %ld, %ld", curtext.min_index, curtext.max_index); break; case COLRPREC: /* Colour Precision */ MOTprcode ( COLRPREC ); curtext.col_prec = (Long) (1L< 70 ) { TEXTOUT "\n%9s", " "); k = strlen ( &str[j] ) + 4; } MOTstring ( &str[j] ); j = *pi++; } break; case CHARSETLIST: /* Character set list */ MOTprcode ( CHARSETLIST ); for ( j = ZERO; j < num ; ) { MOTenum ( "STD94/STD96/STD94MULTIBYTE/STD96MULTIBYTE/COMPLETECODE", (Enum) *pi++); MOTstring ( &str[j] ); j = *pi++; } break; case CHARCODING: /* Character coding Announcer */ MOTprcode ( CHARCODING ); MOTenum ("BASIC7BIT/BASIC8BIT/EXTD7BIT/EXTD8BIT", (Enum) num); break; } break; case 0x32: /* Picture Descriptor Elements */ switch (c) { case SCALEMODE: /* Scaling Mode */ MOTprcode ( SCALEMODE ); MOTenum ("abstract/metric", cur.scale_mode); TEXTOUT ", %.*f", rp, (Double)cur.scale_factor); break; case COLRMODE: /* Colour Selection Mode */ MOTprcode ( COLRMODE ); MOTenum ("indexed/direct", cur.color_mode); break; case LINEWIDTHMODE: /* Line width Specification */ MOTprcode ( LINEWIDTHMODE ); MOTenum ("abs/scaled", cur.linewidth_mode); break; case MARKERSIZEMODE: /* Marker size Specification */ MOTprcode ( MARKERSIZEMODE ); MOTenum ("abs/scaled", cur.markersize_mode); break; case EDGEWIDTHMODE: /* Edge width Specification */ MOTprcode ( EDGEWIDTHMODE ); MOTenum ("abs/scaled", cur.edgewidth_mode); break; case VDCEXT: /* VDC Extent */ MOTprcode ( VDCEXT ); if (cur.vdc_type == REAL) TEXTOUT " (%.*f,%.*f) (%.*f,%.*f)", vp, (double)cur.vdc_extent.a.x.real, vp, (double)cur.vdc_extent.a.y.real, vp, (double)cur.vdc_extent.b.x.real, vp, (double)cur.vdc_extent.b.y.real ); else TEXTOUT " (%ld,%ld) (%ld,%ld)", cur.vdc_extent.a.x.intr, cur.vdc_extent.a.y.intr, cur.vdc_extent.b.x.intr, cur.vdc_extent.b.y.intr ); break; case BACKCOLR: /* Background Colour */ MOTprcode ( BACKCOLR ); MOTcol(&cur.back, DIRECT); break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } break; case 0x33: /* Control Elements */ switch(c) { case VDCINTEGERPREC: /* VDC Integer Precision */ MOTprcode ( VDCINTEGERPREC ); curtext.max_vdc.intr = (Long) (1L<<(cur.vdcint_bits - 1)) -1; curtext.min_vdc.intr = (long) (- curtext.max_vdc.intr - 1); TEXTOUT " %ld, %ld", (long)curtext.min_vdc.intr, (long)curtext.max_vdc.intr); TEXTOUT " %ld", cur.vdcint_bits); break; case VDCREALPREC: /* VDC Real Precision */ MOTprcode ( VDCREALPREC ); curtext.max_vdc.real = cur.max_vdc; curtext.min_vdc.real = cur.min_vdc; curtext.vdc_digits = (long)(1.0 + (cur.vdc_bits - cur.vdc_places) * LOG2); vp = (long)( cur.vdc_places < 0 ? 1.0-cur.vdc_places*LOG2 : 0); TEXTOUT " %.*f, %.*f,", vp, (double)curtext.min_vdc.real, vp, (double)curtext.max_vdc.real); TEXTOUT " %ld", curtext.vdc_digits); TEXTOUT " %ld", cur.vdc_bits); break; case AUXCOLR: /* Auxiliary Colour */ MOTprcode ( AUXCOLR ); MOTcol(&cur.aux, cur.color_mode); break; case TRANSPARENCY: /* Transparency */ MOTprcode ( TRANSPARENCY ); MOTenum ("off/on", cur.transparency); break; case CLIPRECT: /* Clip Rectangle */ MOTprcode ( CLIPRECT ); if (cur.vdc_type == REAL) TEXTOUT " (%.*f,%.*f) (%.*f,%.*f)", vp, (double)cur.clip_rect.a.x.real, vp, (double)cur.clip_rect.a.y.real, vp, (double)cur.clip_rect.b.x.real, vp, (double)cur.clip_rect.b.y.real ); else TEXTOUT " (%ld,%ld) (%ld,%ld)", cur.clip_rect.a.x.intr, cur.clip_rect.a.y.intr, cur.clip_rect.b.x.intr, cur.clip_rect.b.y.intr ); break; case CLIP: /* Clip Indicator */ MOTprcode ( CLIP ); MOTenum ("off/on", cur.clip_ind); break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } break; case 0x34: /* Circles and Ellipses */ switch(c) { case CIRCLE: /* Circle */ MOTprcode ( CIRCLE ); MOTpoints ((Long)1, pi, pr, ZERO); MOTvdc ((Int)1, pi+2, pr+2 ); break; case ARC3PT: /* Circular Arc 3 point */ MOTprcode ( ARC3PT ); MOTpoints ((Long)3, pi, pr, ZERO); break; case ARC3PTCLOSE: /* Circular Arc 3 point close */ MOTprcode ( ARC3PTCLOSE ); MOTpoints ((Long)3, pi, pr, ZERO); MOTenum ("pie/chord", (Enum) *(pi+6) ); break; case ARCCTR: /* Circle Arc centre */ MOTprcode ( ARCCTR ); MOTpoints ((Long)3, pi, pr, ZERO); MOTvdc ((Int)1, pi+6, pr+6); break; case ARCCTRCLOSE: /* Circle Arc centre close */ MOTprcode ( ARCCTRCLOSE ); MOTpoints ((Long)3, pi, pr, ZERO); MOTvdc((Int)1, pi+6, pr+6); MOTenum ("pie/chord", (Enum) *(pi+7) ); break; case ELLIPSE: /* Ellipse */ MOTprcode ( ELLIPSE ); MOTpoints ((Long)3, pi, pr, ZERO); break; case ELLIPARC: /* Elliptical Arc */ MOTprcode ( ELLIPARC ); MOTpoints ((Long)5, pi, pr, ZERO); break; case ELLIPARCCLOSE: /* Elliptical Arc close*/ MOTprcode ( ELLIPARCCLOSE ); MOTpoints ((Long)5, pi, pr, ZERO); MOTenum ("pie/chord", (Enum) *(pi+10) ); break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } break; case 0x35: /* Attributes */ switch(c) { case LINEINDEX: /* Line Bundle index */ MOTprcode ( LINEINDEX ); TEXTOUT " %ld", curatt.line_ind); break; case LINETYPE: /* Line Type */ MOTprcode ( LINETYPE ); TEXTOUT " %ld", curatt.line_type); break; case LINEWIDTH: /* Line Width */ MOTprcode ( LINEWIDTH ); if (cur.linewidth_mode == SCALED || cur.vdc_type == REAL) TEXTOUT " %.*f", rp, (double)curatt.line_width.real); else TEXTOUT " %ld", curatt.line_width.intr); break; case LINECOLR: /* Line Colour */ MOTprcode ( LINECOLR ); MOTcol(&curatt.line, cur.color_mode); break; case MARKERINDEX: /* Marker Bundle index */ MOTprcode ( MARKERINDEX ); TEXTOUT " %ld", curatt.mark_ind); break; case MARKERTYPE: /* Marker Type */ MOTprcode ( MARKERTYPE ); TEXTOUT " %ld", curatt.mark_type); break; case MARKERSIZE: /* Marker Size */ MOTprcode ( MARKERSIZE ); if (cur.markersize_mode == SCALED || cur.vdc_type == REAL) TEXTOUT " %.*f", rp, (double)curatt.mark_size.real); else TEXTOUT " %ld", curatt.mark_size.intr); break; case MARKERCOLR: /* Marker Colour */ MOTprcode ( MARKERCOLR ); MOTcol(&curatt.marker, cur.color_mode); break; case TEXTINDEX: /* Text Bundle index */ MOTprcode ( TEXTINDEX ); TEXTOUT " %ld", curatt.text_ind); break; case TEXTFONTINDEX: /* Text Font Index */ MOTprcode ( TEXTFONTINDEX ); TEXTOUT " %ld", curatt.text_font); break; case TEXTPREC: /* Text Precision */ MOTprcode ( TEXTPREC ); MOTenum ("string/char/stroke", curatt.text_prec); break; case CHAREXPAN: /* Character Expansion Factor */ MOTprcode ( CHAREXPAN ); TEXTOUT " %.*f", rp, (double)curatt.char_exp); break; case CHARSPACE: /* Character Spacing */ MOTprcode ( CHARSPACE ); TEXTOUT " %.*f", rp, (double)curatt.char_space); break; case TEXTCOLR: /* Text Colour */ MOTprcode ( TEXTCOLR ); MOTcol(&curatt.text, cur.color_mode); break; case CHARHEIGHT: /* Character Height */ MOTprcode ( CHARHEIGHT ); if ( cur.vdc_type == REAL) TEXTOUT " %.*f", vp, (double)curatt.char_height.real); else TEXTOUT " %ld", curatt.char_height.intr); break; case CHARORI: /* Character Orientation */ MOTprcode ( CHARORI ); if (cur.vdc_type == REAL) TEXTOUT " %.*f %.*f, %.*f %.*f", vp, (double)curatt.char_up.x.real, vp, (double)curatt.char_up.y.real, vp, (double)curatt.char_base.x.real, vp, (double)curatt.char_base.y.real ); else TEXTOUT " %ld %ld, %ld %ld", curatt.char_up.x.intr, curatt.char_up.y.intr, curatt.char_base.x.intr, curatt.char_base.y.intr ); break; case TEXTPATH: /* Text Path */ MOTprcode ( TEXTPATH ); MOTenum ("right/left/up/down", curatt.text_path); break; case TEXTALIGN: /* Text Alignment */ MOTprcode ( TEXTALIGN ); MOTenum ("normhoriz/left/ctr/right/conthoriz", curatt.text_halign); TEXTOUT ", "); MOTenum ("normvert/top/cap/half/base/bottom/contvert", curatt.text_valign); TEXTOUT ", %.*f, %.*f", rp, (double)curatt.text_hcont, rp, (double)curatt.text_vcont ); break; case CHARSETINDEX: /* Character Set Index */ MOTprcode ( CHARSETINDEX ); TEXTOUT " %ld", curatt.char_set); break; case ALTCHARSETINDEX: /* Alternative Character Set Index */ MOTprcode ( ALTCHARSETINDEX ); TEXTOUT " %ld", curatt.altchar_set); break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } break; case 0x36: /* More Attributes */ switch(c) { case FILLINDEX: /* Fill Bundle index */ MOTprcode ( FILLINDEX ); TEXTOUT " %ld", curatt.fill_ind); break; case INTSTYLE: /* Interior Style */ MOTprcode ( INTSTYLE ); MOTenum ("hollow/solid/pat/hatch/empty",curatt.int_style); break; case FILLCOLR: /* Fill Colour */ MOTprcode ( FILLCOLR ); MOTcol(&curatt.fill, cur.color_mode); break; case HATCHINDEX: /* Hatch Index */ MOTprcode ( HATCHINDEX ); TEXTOUT " %ld", curatt.hatch_ind); break; case PATINDEX: /* Pattern Index */ MOTprcode ( PATINDEX ); TEXTOUT " %ld", curatt.pat_ind); break; case EDGEINDEX: /* Edge Bundle index */ MOTprcode ( EDGEINDEX ); TEXTOUT " %ld", curatt.edge_ind); break; case EDGETYPE: /* Edge Type */ MOTprcode ( EDGETYPE ); TEXTOUT " %ld", curatt.edge_type); break; case EDGEWIDTH: /* Edge Width */ MOTprcode ( EDGEWIDTH ); if (cur.edgewidth_mode == SCALED || cur.vdc_type == REAL) TEXTOUT " %.*f", rp, (double)curatt.edge_width.real); else TEXTOUT " %ld", curatt.edge_width.intr); break; case EDGECOLR: /* Edge Colour */ MOTprcode ( EDGECOLR ); MOTcol(&curatt.edge, cur.color_mode); break; case EDGEVIS: /* Edge Visibility */ MOTprcode ( EDGEVIS ); MOTenum ("off/on",curatt.edge_vis); break; case FILLREFPT: /* Fill Reference Point */ MOTprcode ( FILLREFPT ); if (cur.vdc_type == REAL) TEXTOUT " (%.*f,%.*f)", vp, (double)curatt.fill_ref.x.real, vp, (double)curatt.fill_ref.y.real ); else TEXTOUT " (%ld,%ld)", curatt.fill_ref.x.intr, curatt.fill_ref.y.intr ); break; case PATTABLE: /* Pattern Table */ if ( first ) { MOTprcode ( PATTABLE ); TEXTOUT " %ld,", *pi++); nx = *pi++; ny = *pi++; loc_prec = *pi++; TEXTOUT " %ld, %ld, %ld\n", nx, ny, (1L<<(loc_prec-1)) -1); } first = (num >= ZERO ); if (num < ZERO ) num = -num; prec = (unsigned long) (loc_prec * LOG2 + 1); if ( prec < 2 ) prec = 2; if ( cur.color_mode == INDEXED ) k = 80 / (prec+1); else k = 80 / (3*prec+5); if ( k > nx ) k = nx; n = nx; i = k; for (j = ZERO; j < num; j++ ) { if ( j ) { if ( j == k || j == n ) { TEXTOUT ",\n"); k += i; if ( j == n ) { n += nx; k = j + i; } } else TEXTOUT ", "); } if ( cur.color_mode == INDEXED ) TEXTOUT "%*ld", (int)prec, *pi++); else { TEXTOUT "%*ld %*ld %*ld", (int)prec, *pi, (int)prec, *(pi+1), (int)prec, *(pi+2)); pi += 3; } } break; case PATSIZE: /* Pattern Size */ MOTprcode ( PATSIZE ); if (cur.vdc_type == REAL) TEXTOUT " %.*f %.*f, %.*f %.*f", vp, (double)curatt.pat_size.a.x.real, vp, (double)curatt.pat_size.a.y.real, vp, (double)curatt.pat_size.b.x.real, vp, (double)curatt.pat_size.b.y.real ); else TEXTOUT " %ld %ld, %ld %ld", curatt.pat_size.a.x.intr, curatt.pat_size.a.y.intr, curatt.pat_size.b.x.intr, curatt.pat_size.b.y.intr ); break; case COLRTABLE: /* Colour Table */ MOTprcode ( COLRTABLE ); TEXTOUT " %ld ", *pi++); for (j = ZERO; j < num ; j++ ) { if (j) TEXTOUT ",\n%*s", indent+12," "); TEXTOUT " %ld %ld %ld", *pi, *(pi+1), *(pi+2)); pi += 3; } break; case ASF: /* Aspect source flags */ MOTprcode ( ASF ); for (n = ZERO ; n < num ; n ++ ) { if ( n ) TEXTOUT ",\n%*s", indent+3, " "); if ( *pi < ASFS ) MOTenum ("linetype/linewidth/linecolr/markertype/markersize/markercolr/textfontindex/textprec/charexp/charspace/textcolr/intstyle/fillcolr/hatchindex/patindex/edgetype/edgewidth/edgecolr", (Enum) *pi++); /* charexp should be changed to charexpan */ else MOTenum ("alledge/allfill/alltext/allmarker/allline/all", (Enum) (*(pi++) - 506) ); MOTenum ("indiv/bundled", (Enum) *pi++); } break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } break; case 0x37: /* Escape And External Elements */ switch (c) { case ESCAPE: /* Escape */ MOTprcode ( ESCAPE ); TEXTOUT " %ld ", num); MOTstring ( str ); break; case MESSAGE: /* Message */ MOTprcode ( MESSAGE ); MOTenum ("noaction /action ", (Enum) num); MOTstring ( str ); break; case APPLDATA: /* Application Data */ MOTprcode ( APPLDATA ); TEXTOUT " %ld ", num); MOTstring ( str ); break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } break; default: (void) sprintf( mess, "(code: 0x%x)", c); break; } if ( first && c != NONOP ) TEXTOUT ";\n"); return; } /******************************************************* MOTpoints *****/ static void MOTpoints (Long n, Long *pi, float *pr, Enum set) { /* Output 'n' points starting at pi/pr 'set' indicates if this is a POLYGONSET */ register Long i, k, no; register int prec; /* Set number of points to print on each line */ if (cur.vdc_type == REAL) { prec = vp; no = 80 - 2*(prec + 6*set + 5); } else { prec = (int) (cur.vdcint_bits*LOG2 + 1); no = 80 - 2*(prec + 6*set + 3); } n = abs(n); for (i = 0, k = 10 ; i < n ; i++ ) { if ( k > no ) { TEXTOUT "\n"); k = 0; } if (cur.vdc_type == REAL) { k += fprintf(cgmot, " (%.*f,%.*f)", prec, (double)*pr, prec, (double)*(pr+1)); pr += 2; } else { k += fprintf(cgmot, " (%ld,%ld)", *pi, *(pi+1) ); pi += 2; } if (set) { MOTenum("invis/vis/closeinvis/closevis", (Enum) *pi++ ); k += 10; } } return; } /******************************************************* MOTvdc ********/ static void MOTvdc (int n, Long *pi, Float *pr) { /* Output 'n' VDCs strating at pi/pr */ register Long j, k, no; register Prec prec; if (cur.vdc_type == REAL) { prec = vp; no = 80 / (prec + 5); } else { prec = (long) (cur.vdcint_bits*LOG2 + 1); no = 80 / (prec + 3); } for ( j = 0, k = no ; j < n ; j++ ) { if (cur.vdc_type == REAL) TEXTOUT " %.*f ", (int)prec, (double)*pr++ ); else TEXTOUT " %ld ", *pi++ ); if ( !k-- ) { TEXTOUT "\n"); k = no; } } return; } /******************************************************* MOTcol ********/ static void MOTcol (struct colour *c, Enum type) { /* Output colour 'c' depending on Color_mode 'type' */ if (type == DIRECT) TEXTOUT " %ld %ld %ld", c->red, c->green, c->blue); else TEXTOUT " %ld", c->index); return; } /******************************************************* MOTstring *****/ static void MOTstring( char *s ) { /* Output text string 's' if ' then output '' */ register Long i; TEXTOUT " '"); for ( i = ZERO; i < (int)strlen(s); i++ ) { TEXTOUT "%c", s[i] ); if ( s[i] == '\'' ) TEXTOUT "'"); } TEXTOUT "'"); return; } /******************************************************* MOTenum *******/ static void MOTenum ( char *s, Enum k ) { /* Output enumerated type 'k' using string 's' enumerated values are seperated by '/' */ register Long i = ZERO, j = ZERO, n = k; char s1[16]; /* Find nth '/' */ while ( n-- ) { while ( s[i++] != '/' ) { if ( ! s[i] ) /* end of string found */ { (void) sprintf( mess, "(type: %d)", k); i = 0; /* defaults to first value */ n = 0; /* exit loop */ } } } /* Extract string into s1 until next '/' or end of string */ while ( (s[i] != '/') && s[i] ) s1[j++] = s[i++]; s1[j] = '\0'; /* Print enumerated value */ TEXTOUT " %s", s1); return; } /******************************************************* MOTprcode *****/ static void MOTprcode ( Code code ) { /* Output Metafile element name 'code ' */ register int i, group, index, upcase = FALSE; static int pos[16] = { 0, 2, 4, 6, 7, 8, 9, 11, 13, 14, 15, -1, -1, -1, -1, -1}; char c[16]; group = code & 0xfff0; index = code & 0x000f; switch ( group ) { case LINE: index = pos[index]; upcase = TRUE; break; case CIRCLE: index += 16; upcase = TRUE; break; case LINEINDEX: index += 24; break; case TEXTINDEX: index += 32; break; case FILLINDEX: index += 44; break; case COLRTABLE: index += 57; break; case VDCINTEGERPREC: index += 59; break; case BEGMF: index += 65; upcase = TRUE; break; case MFVERSION: index += 70; if ( code == BEGMFDEFAULTS || code == ENDMFDEFAULTS ) upcase = TRUE; break; case SCALEMODE: index += 86; break; case ESCAPE: index += 93; upcase = TRUE; break; default: index = -1; break; } if ( index >= 0 && code == cgmelement[index].code ) { if ( indent ) TEXTOUT "%*s", indent, " " ); strcpy(c, cgmelement[index].string); if ( ! upcase ) for ( i = 0; i < (int)strlen(c); i++) c[i] = (char)tolower( c[i] ); TEXTOUT "%s", c ); return; } (void) sprintf(mess, "(code: %x)", code); return; }