![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printrast.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / dimpress|
Return to printrast.c CVS log | Up to [Research Unix] / researchv10no / cmd / dimpress |
1.1 ! root 1: ! 2: ! 3: /* ! 4: * ! 5: * Reads the raster files listed as arguments and prints the glyphs, along ! 6: * with information about character widths and glyph numbers, on an Imagen ! 7: * printer. The output is written in Impress. If no glyphs are selected by ! 8: * using the -o option the entire file or files will be printed. An Impress ! 9: * document header is the first thing written to the output file provided ! 10: * want_header == TRUE. Use the -H option to force the header. The target ! 11: * printer is assumed to have a resolution of res dots per inch, which by ! 12: * default is set to RAST_RES (probably 300). If that's not the case use ! 13: * the -r option to select a new resolution. It's really only important ! 14: * in determining the pixel length of a page. ! 15: * ! 16: * Text in the printout is written using font *font in size list_size. ! 17: * By default it's resident font cour10. You can change the requested font ! 18: * and size using the -f and -s options respectively. ! 19: * ! 20: * All the raster files are assumed to be in directory *rastdir, which by ! 21: * default is set to ".". *rastdir can be changed by using the -R option. ! 22: * but in all cases the string "*rastdir/" is prepended to the raster file ! 23: * names to get the complete pathname. ! 24: * ! 25: * As an example the command line, ! 26: * ! 27: * printrast -R /usr/lib/raster/rasti300 -H -r 300 R.10 I.10 >xxx ! 28: * ! 29: * will write the Impress commands needed to print the glyphs in raster ! 30: * file /usr/lib/raster/rasti300/R.10 and /usr/lib/raster/rasti300/I.10 out ! 31: * to file xxx. The target printer is assumed to have a resolution of 300 ! 32: * dots per inch. The output file xxx begins with a document header defining ! 33: * the language to be Impress and can therefore be set directly to an 8/300. ! 34: * ! 35: * A word of warning is in order here. Because I've written readrastfile() ! 36: * so it accepts two different raster file naming conventions there isn't ! 37: * a one to one mapping of file names to font name, size pairs. That means ! 38: * if you have two similiarly named raster files, differing only in the ! 39: * naming convention used, and you keep them in the same directory you'll ! 40: * always display glyphs from the preferred file no matter which file ! 41: * you list on the command line. I don't think it will cause any real ! 42: * problems so I'm not going to change any of this stuff. ! 43: * ! 44: */ ! 45: ! 46: ! 47: #include <stdio.h> ! 48: ! 49: #include "gen.h" /* general purpose definitions */ ! 50: #include "ext.h" /* external variable declarations */ ! 51: #include "rast.h" /* raster file definitions */ ! 52: #include "impcodes.h" /* Impress opcode definitions */ ! 53: ! 54: ! 55: FILE *fp_out = stdout; /* output file - probably won't change */ ! 56: ! 57: char *font = "cour"; /* use this font for printing text */ ! 58: int list_size = 10; /* and this point size */ ! 59: ! 60: float xoffset = .25; /* start this far from left edge */ ! 61: float yoffset = .50; /* and this far down the page - inches */ ! 62: ! 63: int p_xoffset; /* same as last two but in pixels */ ! 64: int p_yoffset; ! 65: ! 66: float height = 10.50; /* height of the paper in inches */ ! 67: float width = 8.75; /* same but for paper width */ ! 68: ! 69: int p_height; /* paper dimensions in pixels */ ! 70: int p_width; ! 71: ! 72: int res = RAST_RES; /* resolution of the target printer */ ! 73: ! 74: int hpos; /* current horizontal position - pixels */ ! 75: int vpos; /* same but for vertical position */ ! 76: ! 77: int linesp; /* interline spacing */ ! 78: int spacewid; /* interword spacing */ ! 79: ! 80: int want_header = FALSE; /* write document header first */ ! 81: ! 82: ! 83: /*****************************************************************************/ ! 84: ! 85: ! 86: main(agc, agv) ! 87: ! 88: ! 89: int agc; ! 90: char *agv[]; ! 91: ! 92: ! 93: { ! 94: ! 95: ! 96: /* ! 97: * ! 98: * Reads Imagen formatted raster files and writes the Impress commands ! 99: * needed to print the glyphs, along with width and index data, to fp_out. ! 100: * Text is written using resident the resident font whose name is built ! 101: * by concatenating *font and list_size. By default the font is cour10, ! 102: * but both font and list_size can be changed by options. Individual glyphs ! 103: * in the raster files can be selected, rather than the whole file, by ! 104: * using the -o option (although I haven't tested this yet). ! 105: * ! 106: */ ! 107: ! 108: ! 109: argc = agc; /* other routines may want them */ ! 110: argv = agv; ! 111: ! 112: prog_name = argv[0]; /* really just for error messages */ ! 113: rastdir = "."; /* current directory by default */ ! 114: ! 115: options(); /* first get command line options */ ! 116: doc_header(); /* make sure this comes first */ ! 117: initialize(); /* must be done after options */ ! 118: arguments(); /* then process non-option arguments */ ! 119: ! 120: exit(x_stat); /* everything probably went OK */ ! 121: ! 122: } /* End of main */ ! 123: ! 124: ! 125: /*****************************************************************************/ ! 126: ! 127: ! 128: options() ! 129: ! 130: ! 131: { ! 132: ! 133: ! 134: int ch; /* return value from getopt() */ ! 135: char *names = "DIFHR:o:x:y:r:h:w:s:"; ! 136: ! 137: extern char *optarg; /* used by getopt() */ ! 138: extern int optind; ! 139: ! 140: float atof(); ! 141: ! 142: ! 143: /* ! 144: * ! 145: * Reads and processes the command line options. Right now the recognized ! 146: * options are, ! 147: * ! 148: */ ! 149: ! 150: ! 151: while ( (ch = getopt(argc, argv, names)) != EOF ) { ! 152: ! 153: switch ( ch ) { ! 154: ! 155: case 'r': /* target printer resolution */ ! 156: res = atoi(optarg); ! 157: break; ! 158: ! 159: case 'f': /* use this font (omit size) */ ! 160: font = optarg; ! 161: break; ! 162: ! 163: case 's': /* use this point size */ ! 164: list_size = atoi(optarg); ! 165: break; ! 166: ! 167: case 'h': /* set the paper height - inches */ ! 168: height = atof(optarg); ! 169: break; ! 170: ! 171: case 'w': /* same but for the width */ ! 172: width = atof(optarg); ! 173: break; ! 174: ! 175: case 'x': /* set the xoffset - inches */ ! 176: xoffset = atof(optarg); ! 177: break; ! 178: ! 179: case 'y': /* same but for yoffset */ ! 180: yoffset = atof(optarg); ! 181: break; ! 182: ! 183: case 'o': /* processing range list */ ! 184: out_list(optarg); ! 185: break; ! 186: ! 187: case 'H': /* want the document header */ ! 188: want_header = TRUE; ! 189: break; ! 190: ! 191: case 'F': /* new troff font directory */ ! 192: fontdir = optarg; ! 193: break; ! 194: ! 195: case 'R': /* set raster table directory */ ! 196: rastdir = optarg; ! 197: break; ! 198: ! 199: case 'D': /* debug flag */ ! 200: debug = ON; ! 201: break; ! 202: ! 203: case 'I': /* ignore FATAL errors */ ! 204: ignore = ON; ! 205: break; ! 206: ! 207: case '?': /* don't understand the option */ ! 208: error(FATAL, ""); ! 209: break; ! 210: ! 211: default: /* don't know what to do for ch */ ! 212: error(FATAL, "missing case for option %c\n", ch); ! 213: break; ! 214: ! 215: } /* End switch */ ! 216: ! 217: } /* End while */ ! 218: ! 219: argc -= optind; /* get ready for non-option args */ ! 220: argv += optind; ! 221: ! 222: } /* End of options */ ! 223: ! 224: ! 225: /*****************************************************************************/ ! 226: ! 227: ! 228: doc_header() ! 229: ! 230: ! 231: { ! 232: ! 233: ! 234: /* ! 235: * ! 236: * If want_header is TRUE we'll make sure a document header is the first ! 237: * thing written to the output file. ! 238: * ! 239: */ ! 240: ! 241: ! 242: if ( want_header == TRUE ) ! 243: fprintf(fp_out, "@document(language impress)"); ! 244: ! 245: } /* End of doc_header */ ! 246: ! 247: ! 248: /*****************************************************************************/ ! 249: ! 250: ! 251: initialize() ! 252: ! 253: ! 254: { ! 255: ! 256: ! 257: /* ! 258: * ! 259: * Does the run time initialization of variables that depend on the target ! 260: * printer resolution. Also handles printer initialization of things like ! 261: * the space width and creating the listing font family table. ! 262: * ! 263: */ ! 264: ! 265: ! 266: p_xoffset = xoffset * res; ! 267: p_yoffset = yoffset * res; ! 268: ! 269: p_height = height * res; ! 270: p_width = width * res; ! 271: ! 272: spacewid = 2.2 * list_size; /* a reasonable value for spaces */ ! 273: ! 274: putc(ASETSP, fp_out); ! 275: putint(spacewid, fp_out); ! 276: ! 277: putc(ACFT, fp_out); /* use resident font */ ! 278: putc(MAXFAMILY, fp_out); ! 279: putc(1, fp_out); ! 280: putc(0, fp_out); ! 281: fprintf(fp_out, "%s%d", font, list_size); ! 282: putc('\0', fp_out); ! 283: ! 284: } /* End of initialize */ ! 285: ! 286: ! 287: /*****************************************************************************/ ! 288: ! 289: ! 290: arguments() ! 291: ! 292: ! 293: { ! 294: ! 295: ! 296: char name[100]; /* make sure we can acces file */ ! 297: char *font; /* name of the font we're dumping */ ! 298: char *size; /* in this point size */ ! 299: ! 300: char *strtok(); ! 301: ! 302: ! 303: /* ! 304: * ! 305: * All the remaining arguments are the names of raster files in *rastdir ! 306: * that we want to display. Because two raster file naming conventions ! 307: * are used in rast.c we can't be absolutely sure we're really displaying ! 308: * the raster file that the user wanted. That's why the pathname is built ! 309: * up in name[] and access to the file is checked. That's probably good ! 310: * enough for our purposes, but it still doesn't guarantee you get what ! 311: * you asked for. It shouldn't cause any real problems as long as you ! 312: * don't try and keep raster files with the two different naming conventions ! 313: * in the same directory. ! 314: * ! 315: */ ! 316: ! 317: ! 318: if ( argc < 1 ) ! 319: error(FATAL, "can't read standard input"); ! 320: else { /* have at least one argument */ ! 321: while ( argc > 0 ) { ! 322: sprintf(name, "%s/%s", rastdir, *argv); ! 323: if ( access(name, 04) == -1 ) ! 324: error(FATAL, "can't read file %s", name); ! 325: ! 326: if ( (font = strtok(*argv, ".")) == NULL ) ! 327: error(FATAL, "bad raster file name %s", *argv); ! 328: ! 329: if ( *(size = font + strlen(font) + 1) == 'r' ) size++; ! 330: ! 331: printrast(font, atoi(size)); ! 332: argc--; ! 333: argv++; ! 334: } /* End while */ ! 335: } /* End else */ ! 336: ! 337: } /* End of arguments */ ! 338: ! 339: ! 340: /*****************************************************************************/ ! 341: ! 342: ! 343: printrast(name, size) ! 344: ! 345: ! 346: char *name; /* name of the font */ ! 347: int size; /* in this point size */ ! 348: ! 349: ! 350: { ! 351: ! 352: ! 353: int start, stop; /* glyph number end points */ ! 354: int i; /* loop index */ ! 355: int cwid; /* character width */ ! 356: int xref, yref; /* reference point for current glyph */ ! 357: char buff[200]; /* text string buffer */ ! 358: ! 359: ! 360: /* ! 361: * ! 362: * Prints glyphs from the raster file associated with font *name in point ! 363: * size 'size'. If no -o option was given all the glyphs will be printed. ! 364: * The listing for each new font begins on a new page. ! 365: * ! 366: */ ! 367: ! 368: ! 369: getrastdata(name, size); /* read the font's raster file */ ! 370: ! 371: start = getvalue(P_FIRSTGLY); /* first glyph number in the font */ ! 372: stop = getvalue(P_LASTGLY); /* number of the last glyph */ ! 373: ! 374: linesp = ((MAX(size, list_size) + .2 * MAX(size, list_size)) / 72.27) * RAST_RES + 1.0; ! 375: ! 376: newpage(); /* dump starts on a new page */ ! 377: ! 378: sprintf(buff, "FONT DUMP FOR %s: SIZE %d\n\n\n", name, size); ! 379: printstring(buff); ! 380: ! 381: for ( i = start; i <= stop; i++ ) ! 382: if ( in_olist(i) == ON ) { ! 383: printchar(i, name, size, -1, fp_out); ! 384: cwid = PIXEL_WIDTH(getvalue(G_CHWIDTH, i), rast_res); ! 385: xref = getvalue(G_XREF, i); ! 386: yref = getvalue(G_YREF, i); ! 387: hpos = 6 * spacewid + p_xoffset; ! 388: xymove(); ! 389: sprintf(buff, "width = %d code = %d xref = %d yref = %d\n", cwid, i, xref, yref); ! 390: printstring(buff); ! 391: } /* End if */ ! 392: ! 393: } /* End of printrast */ ! 394: ! 395: ! 396: /*****************************************************************************/ ! 397: ! 398: ! 399: printchar(c, font, size, advance, fp) ! 400: ! 401: ! 402: int c; /* print glyph for this character */ ! 403: char *font; /* in this font */ ! 404: int size; /* and this point size */ ! 405: int advance; /* using this as the advance width */ ! 406: FILE *fp; /* Impress commands go here */ ! 407: ! 408: ! 409: { ! 410: ! 411: ! 412: /* ! 413: * ! 414: * Does everything needed to get character c printed using the raster file ! 415: * for *font in point size 'size' and using advance as the character advance. ! 416: * ! 417: */ ! 418: ! 419: ! 420: if ( fam == NULL || fam->size != size || strcmp(font, fam->name) != 0 || fam->rst == NULL ) ! 421: getrastdata(font, size); ! 422: ! 423: putc(download(c, advance, ROT_0, fp), fp); ! 424: ! 425: } /* End of printchar */ ! 426: ! 427: ! 428: /*****************************************************************************/ ! 429: ! 430: ! 431: newline() ! 432: ! 433: ! 434: { ! 435: ! 436: ! 437: /* ! 438: * ! 439: * Makes sure everything is properly set up to start a new line. If the ! 440: * vertical position on the page has gone past p_height (ie. the height ! 441: * of the paper in pixels) we'll start a new page. ! 442: * ! 443: */ ! 444: ! 445: ! 446: hpos = p_xoffset; /* left margin */ ! 447: if ( (vpos += linesp) >= p_height ) ! 448: newpage(); ! 449: else xymove(); ! 450: ! 451: } /* End of newline */ ! 452: ! 453: ! 454: /*****************************************************************************/ ! 455: ! 456: ! 457: newpage() ! 458: ! 459: ! 460: { ! 461: ! 462: ! 463: /* ! 464: * ! 465: * Ends the previous page and makes sure we're positioned at the upper left ! 466: * corner of a new page. The way things are done results in a blank page at ! 467: * the beginning of every job - no big deal because the program isn't used ! 468: * much. ! 469: * ! 470: */ ! 471: ! 472: ! 473: putc(AENDP, fp_out); ! 474: ! 475: hpos = p_xoffset; ! 476: vpos = p_yoffset; ! 477: ! 478: xymove(); ! 479: ! 480: } /* End of newpage */ ! 481: ! 482: ! 483: /*****************************************************************************/ ! 484: ! 485: ! 486: xymove() ! 487: ! 488: ! 489: { ! 490: ! 491: ! 492: /* ! 493: * ! 494: * Makes sure the current position for Impress is set to (hpos, vpos). ! 495: * ! 496: */ ! 497: ! 498: ! 499: putc(ASETAH, fp_out); ! 500: putint(hpos, fp_out); ! 501: ! 502: putc(ASETAV, fp_out); ! 503: putint(vpos, fp_out); ! 504: ! 505: ! 506: } /* End of xymove */ ! 507: ! 508: ! 509: /*****************************************************************************/ ! 510: ! 511: ! 512: printstring(str) ! 513: ! 514: ! 515: char *str; /* want to print this string */ ! 516: ! 517: ! 518: { ! 519: ! 520: ! 521: /* ! 522: * ! 523: * Arranges to have string *str printed using the resident font that's been ! 524: * assigned the family number MAXFAMILY. Spaces and newlines are handled ! 525: * separately, although that probably isn't necessary for resident fonts. ! 526: * ! 527: * Some of the glyphs in the raster files we got from Imagen are bad. It ! 528: * didn't seem to matter much for version 1.9, but a glyph having 0 for its ! 529: * raster height hung version 2.0 and nothing was printed. Anyway I put a ! 530: * check in routine download() to make sure glyphs having no height weren't ! 531: * downloaded. At least that made sure the printer didn't crash. All we ! 532: * get for those glyphs is a harmless undefined glyph message and a ! 533: * special character got printed to mark where the problem occurred. ! 534: * ! 535: */ ! 536: ! 537: ! 538: if ( last_fam != MAXFAMILY ) { /* using this family for listing */ ! 539: putc(ASF, fp_out); /* need to tell printer about it */ ! 540: putc(MAXFAMILY, fp_out); ! 541: last_fam = MAXFAMILY; ! 542: } /* End if */ ! 543: ! 544: while ( *str != '\0' ) { /* print the whole string */ ! 545: if ( *str == ' ' ) ! 546: putc(ASP, fp_out); ! 547: else if ( *str == '\n' ) ! 548: newline(); ! 549: else putc(*str, fp_out); ! 550: str++; ! 551: } /* End while */ ! 552: ! 553: } /* End of printstring */ ! 554: ! 555: ! 556: /*****************************************************************************/ ! 557: ! 558:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.