开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
TextFormat.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：39k
源码类别：

传真(Fax)编程

开发平台：

C/C++

TextFormat.c++：源码内容
  1. /* $Id: TextFormat.c++,v 1.7 2009/07/29 01:40:06 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1993-1996 Sam Leffler
  4.  * Copyright (c) 1993-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  27. /*
  28.  * Text to PostScript conversion and formatting support.
  29.  *
  30.  * This class takes ASCII text and produces PostScript
  31.  * doing formatting using the font metric information
  32.  * for a single font.  Multi-column output, landscape and
  33.  * portrait page orientation, and various other controls
  34.  * are supported.  Page headers a la the old enscript
  35.  * program from Adobe can also be added.  This code is
  36.  * distantly related to the lptops program by Nelson Beebe.
  37.  */
  38. #include "config.h"
  39. #include "Array.h"
  40. #include "Dictionary.h"
  41. #include "PageSize.h"
  42. #include "TextFormat.h"
  43. #include "Sys.h"
  45. #include <ctype.h>
  46. #include <errno.h>
  47. #if HAS_MMAP
  48. #include <sys/mman.h>
  49. #endif
  51. #define LUNIT  (72*20) // local coord system is .05 scale
  52. #define ICVT(x) ((TextCoord)((x)*LUNIT)) // scale inches to local coordinates
  53. #define CVTI(x) (float(x)/LUNIT) // convert coords to inches
  55. inline TextCoord fxmax(TextCoord a, TextCoord b)
  56.     { return (a > b) ? a : b; }
  58. #define COLFRAC 35 // 1/fraction of col width for margin
  60. fxDECLARE_PrimArray(OfftArray, off_t)
  61. fxIMPLEMENT_PrimArray(OfftArray, off_t)
  62. fxDECLARE_StrKeyDictionary(FontDict, TextFont*)
  63. fxIMPLEMENT_StrKeyPtrValueDictionary(FontDict, TextFont*)
  65. TextFormat::TextFormat()
  66. {
  67.     output = NULL;
  68.     tf = NULL;
  69.     pageOff = new OfftArray;
  71.     firstPageNum = 1; // starting page number
  72.     column = 1; // current text column # (1..numcol)
  73.     pageNum = 1; // current page number
  74.     workStarted = false;
  76.     fonts = new FontDict;
  77.     curFont = addFont("Roman", "Courier");
  79.     TextFormat::setupConfig(); // NB: virtual
  80. }
  82. TextFormat::~TextFormat()
  83. {
  84.     for (FontDictIter iter(*fonts); iter.notDone(); iter++)
  85. delete iter.value();
  86.     delete fonts;
  87.     if (tf != NULL)
  88. fclose(tf);
  89.     tf = NULL;
  90. }
  92. void
  93. TextFormat::warning(const char* fmt ...) const
  94. {
  95.     fputs("Warning, ", stderr);
  96.     va_list ap;
  97.     va_start(ap, fmt);
  98.     vfprintf(stderr, fmt, ap);
  99.     va_end(ap);
  100.     fputs(".n", stderr);
  101. }
  103. void
  104. TextFormat::error(const char* fmt ...) const
  105. {
  106.     va_list ap;
  107.     va_start(ap, fmt);
  108.     vfprintf(stderr, fmt, ap);
  109.     va_end(ap);
  110.     fputs(".n", stderr);
  111. }
  113. void
  114. TextFormat::fatal(const char* fmt ...) const
  115. {
  116.     va_list ap;
  117.     va_start(ap, fmt);
  118.     vfprintf(stderr, fmt, ap);
  119.     va_end(ap);
  120.     fputs(".n", stderr);
  121.     exit(1);
  122. }
  124. TextFont*
  125. TextFormat::addFont(const char* name, const char* family)
  126. {
  127.     TextFont* f = new TextFont(family);
  128.     (*fonts)[name] = f;
  129.     if (workStarted) {
  130. fxStr emsg;
  131. if (!f->readMetrics(pointSize, useISO8859, emsg))
  132.     error("Font %s: %s", f->getFamily(), (const char*) emsg);
  133.     }
  134.     return (f);
  135. }
  137. const TextFont*
  138. TextFormat::getFont(const char* name) const
  139. {
  140.     return (*fonts)[name];
  141. }
  143. void TextFormat::setFont(TextFont* f) { curFont = f; }
  144. void TextFormat::setFont(const char* name) { curFont = (*fonts)[name]; }
  145. void TextFormat::setFontPath(const char* path) { TextFont::fontPath = path; }
  147. void TextFormat::setOutputFile(FILE* f) { output = f; }
  148. void TextFormat::setNumberOfColumns(u_int n) { numcol = n; }
  149. void TextFormat::setPageHeaders(bool b) { headers = b; }
  150. void TextFormat::setISO8859(bool b) { useISO8859 = b; }
  151. void TextFormat::setLineWrapping(bool b) { wrapLines = b; }
  152. void TextFormat::setOutlineMargin(TextCoord o) { outline = o; }
  153. void TextFormat::setTextPointSize(TextCoord p) { pointSize = p; }
  154. void TextFormat::setPageOrientation(u_int o) { landscape = (o == LANDSCAPE); }
  155. void TextFormat::setPageCollation(u_int c) { reverse = (c == REVERSE); }
  156. void TextFormat::setTextLineHeight(TextCoord h) { lineHeight = h; }
  157. void TextFormat::setTitle(const char* cp) { title = cp; }
  158. void TextFormat::setFilename(const char* cp) { curFile = cp; }
  160. void
  161. TextFormat::setGaudyHeaders(bool b)
  162. {
  163.     gaudy = b;
  164.     if (gaudy)
  165. headers = true;
  166. }
  168. bool
  169. TextFormat::setTextFont(const char* name)
  170. {
  171.     if (TextFont::findFont(name)) {
  172. (*fonts)["Roman"]->family = name;
  173. return (true);
  174.     } else
  175. return (false);
  176. }
  179. /*
  180.  * Parse margin syntax: l=#,r=#,t=#,b=#
  181.  */
  182. bool
  183. TextFormat::setPageMargins(const char* s)
  184. {
  185.     for (const char* cp = s; cp && cp[0];) {
  186. if (cp[1] != '=')
  187.     return (false);
  188. TextCoord v = inch(&cp[2]);
  189. switch (tolower(cp[0])) {
  190. case 'b': bm = v; break;
  191. case 'l': lm = v; break;
  192. case 'r': rm = v; break;
  193. case 't': tm = v; break;
  194. default:
  195.     return (false);
  196. }
  197. cp = strchr(cp, ',');
  198. if (cp)
  199.     cp++;
  200.     }
  201.     return (true);
  202. }
  204. void
  205. TextFormat::setPageMargins(TextCoord l, TextCoord r, TextCoord b, TextCoord t)
  206. {
  207.     lm = l;
  208.     rm = r;
  209.     bm = b;
  210.     tm = t;
  211. }
  213. bool
  214. TextFormat::setPageSize(const char* name)
  215. {
  216.     PageSizeInfo* info = PageSizeInfo::getPageSizeByName(name);
  217.     if (info) {
  218. setPageWidth(info->width() / 25.4);
  219. setPageHeight(info->height() / 25.4);
  220. delete info;
  221. return (true);
  222.     } else
  223. return (false);
  224. }
  226. void TextFormat::setPageWidth(float pw) { physPageWidth = pw; }
  227. void TextFormat::setPageHeight(float ph) { physPageHeight = ph; }
  229. void
  230. TextFormat::setModTimeAndDate(time_t t)
  231. {
  232.     struct tm* tm = localtime(&t);
  233.     char buf[30];
  234.     strftime(buf, sizeof (buf), "%X", tm); modTime = buf;
  235.     strftime(buf, sizeof (buf), "%F", tm); modDate = buf;
  236. }
  237. void TextFormat::setModTime(const char* cp) { modTime = cp; }
  238. void TextFormat::setModDate(const char* cp) { modDate = cp; }
  240. void
  241. TextFormat::beginFormatting(FILE* o)
  242. {
  243.     output = o;
  244.     pageHeight = ICVT(physPageHeight);
  245.     pageWidth = ICVT(physPageWidth);
  247.     /*
  248.      * Open the file w+ so that we can reread the temp file.
  249.      */
  250.     tf = Sys::tmpfile();
  251.     if (tf == NULL)
  252. fatal("Cannot open temporary file: %s", strerror(errno));
  254.     numcol = fxmax(1,numcol);
  255.     if (pointSize == -1)
  256. pointSize = inch(numcol > 1 ? "7bp" : "10bp");
  257.     else
  258. pointSize = fxmax(inch("3bp"), pointSize);
  259.     if (pointSize > inch("18bp"))
  260. warning("point size is unusually large (>18pt)");
  261.     // read font metrics
  262.     for (FontDictIter iter(*fonts); iter.notDone(); iter++) {
  263. fxStr emsg;
  264. TextFont* f = iter.value();
  265. if (!f->readMetrics(pointSize, useISO8859, emsg))
  266.     error("Font %s: %s", f->getFamily(), (const char*) emsg);
  267.     }
  268.     outline = fxmax(0L,outline);
  269.     curFont = (*fonts)["Roman"];
  270.     tabWidth = tabStop * curFont->charwidth(' ');
  272.     if (landscape) {
  273. TextCoord t = pageWidth;
  274. pageWidth = pageHeight;
  275. pageHeight = t;
  276.     }
  277.     if (lm+rm >= pageWidth)
  278. fatal("Margin values too large for page; lm %lu rm %lu page width %lu",
  279.     lm, rm, pageWidth);
  280.     if (tm+bm >= pageHeight)
  281. fatal("Margin values too large for page; tm %lu bm %lu page height %lu",
  282.     tm, bm, pageHeight);
  284.     col_width = (pageWidth - (lm + rm))/numcol;
  285.     if (numcol > 1 || outline)
  286. col_margin = col_width/COLFRAC;
  287.     else
  288. col_margin = 0;
  289.     /*
  290.      * TeX's baseline skip is 12pt for
  291.      * 10pt type, we preserve that ratio.
  292.      */
  293.     if (lineHeight <= 0)
  294. lineHeight = (pointSize * 12L) / 10L;
  295.     workStarted = true;
  296. }
  298. void
  299. TextFormat::endFormatting(bool skiptrailer)
  300. {
  301.     emitPrologue();
  302.     /*
  303.      * Now rewind temporary file and write
  304.      * pages to stdout in appropriate order.
  305.      */
  306.     if (reverse) {
  307. rewind(tf);
  308. off_t last = (*pageOff)[pageOff->length()-1];
  309. for (int k = pageNum-firstPageNum; k >= 0; --k) {
  310.     /* copy remainder in reverse order */
  311.     off_t next = (off_t) ftell(stdout);
  312.     Copy_Block((*pageOff)[k],last-1);
  313.     last = (*pageOff)[k];
  314.     (*pageOff)[k] = next;
  315. }
  316.     } else {
  317. off_t last = ftell(tf);
  318. rewind(tf);
  319. Copy_Block(0L, last-1);
  320.     }
  321.     if (fclose(tf))
  322. fatal("Close failure on temporary file: %s", strerror(errno));
  323.     tf = NULL;
  324.     if (!skiptrailer) emitTrailer();
  325.     fflush(output);
  326.     workStarted = false;
  327. }
  329. /* copy bytes b1..b2 to stdout */
  330. void
  331. TextFormat::Copy_Block(off_t b1, off_t b2)
  332. {
  333.     char buf[16*1024];
  334.     for (off_t k = b1; k <= b2; k += sizeof (buf)) {
  335. size_t cc = (size_t) fxmin(sizeof (buf), (size_t) (b2-k+1));
  336. fseek(tf, (long) k, SEEK_SET); // position to desired block
  337. if (fread(buf, 1, (size_t) cc, tf) != cc)
  338.     fatal("Read error during reverse collation: %s", strerror(errno));
  339. if (fwrite(buf, 1, (size_t) cc, output) != cc)
  340.     fatal("Output write error: %s", strerror(errno));
  341.     }
  342. }
  344. static const char* ISOprologue2 = "
  345. /reencodeISO{n
  346.   dup length dict beginn
  347.     {1 index /FID ne {def}{pop pop} ifelse} foralln
  348.     /Encoding ISOLatin1Encoding defn
  349.     currentdictn
  350.   endn
  351. }defn
  352. /findISO{n
  353.   dup /FontType known{n
  354.     dup /FontType get 3 nen
  355.     1 index /CharStrings known{n
  356.       1 index /CharStrings get /Thorn knownn
  357.     }{false}ifelsen
  358.     andn
  359.   }{false}ifelsen
  360. }defn
  361. ";
  363. /*
  364.  * Yech, instead of a single string that we fputs, we
  365.  * break things up into smaller chunks to satisfy braindead
  366.  * compilers...
  367.  */
  368. void
  369. TextFormat::putISOPrologue(void)
  370. {
  371.     fputs("/ISOLatin1Encoding where{pop save true}{false}ifelsen", output);
  372.     fputs("/ISOLatin1Encoding[n", output);
  373.     fputs(" /.notdef /.notdef /.notdef /.notdef /.notdef /.notdefn", output);
  374.     fputs(" /.notdef /.notdef /.notdef /.notdef /.notdef /.notdefn", output);
  375.     fputs(" /.notdef /.notdef /.notdef /.notdef /.notdef /.notdefn", output);
  376.     fputs(" /.notdef /.notdef /.notdef /.notdef /.notdef /.notdefn", output);
  377.     fputs(" /.notdef /.notdef /.notdef /.notdef /.notdef /.notdefn", output);
  378.     fputs(" /.notdef /.notdef /space /exclam /quotedbl /numbersignn", output);
  379.     fputs(" /dollar /percent /ampersand /quoteright /parenleftn", output);
  380.     fputs(" /parenright /asterisk /plus /comma /minus /periodn", output);
  381.     fputs(" /slash /zero /one /two /three /four /five /six /sevenn", output);
  382.     fputs(" /eight /nine /colon /semicolon /less /equal /greatern", output);
  383.     fputs(" /question /at /A /B /C /D /E /F /G /H /I /J /K /L /Mn", output);
  384.     fputs(" /N /O /P /Q /R /S /T /U /V /W /X /Y /Z /bracketleftn", output);
  385.     fputs(" /backslash /bracketright /asciicircum /underscoren", output);
  386.     fputs(" /quoteleft /a /b /c /d /e /f /g /h /i /j /k /l /mn", output);
  387.     fputs(" /n /o /p /q /r /s /t /u /v /w /x /y /z /braceleftn", output);
  388.     fputs(" /bar /braceright /asciitilde /guilsinglright /fractionn", output);
  389.     fputs(" /florin /quotesingle /quotedblleft /guilsinglleft /fin", output);
  390.     fputs(" /fl /endash /dagger /daggerdbl /bullet /quotesinglbasen", output);
  391.     fputs(" /quotedblbase /quotedblright /ellipsis /trademarkn", output);
  392.     fputs(" /perthousand /grave /scaron /circumflex /Scaron /tilden", output);
  393.     fputs(" /breve /zcaron /dotaccent /dotlessi /Zcaron /ringn", output);
  394.     fputs(" /hungarumlaut /ogonek /caron /emdash /space /exclamdownn", output);
  395.     fputs(" /cent /sterling /currency /yen /brokenbar /sectionn", output);
  396.     fputs(" /dieresis /copyright /ordfeminine /guillemotleftn", output);
  397.     fputs(" /logicalnot /hyphen /registered /macron /degreen", output);
  398.     fputs(" /plusminus /twosuperior /threesuperior /acute /mun", output);
  399.     fputs(" /paragraph /periodcentered /cedilla /onesuperiorn", output);
  400.     fputs(" /ordmasculine /guillemotright /onequarter /onehalfn", output);
  401.     fputs(" /threequarters /questiondown /Agrave /Aacuten", output);
  402.     fputs(" /Acircumflex /Atilde /Adieresis /Aring /AE /Ccedillan", output);
  403.     fputs(" /Egrave /Eacute /Ecircumflex /Edieresis /Igrave /Iacuten", output);
  404.     fputs(" /Icircumflex /Idieresis /Eth /Ntilde /Ograve /Oacuten", output);
  405.     fputs(" /Ocircumflex /Otilde /Odieresis /multiply /Oslashn", output);
  406.     fputs(" /Ugrave /Uacute /Ucircumflex /Udieresis /Yacute /Thornn", output);
  407.     fputs(" /germandbls /agrave /aacute /acircumflex /atilden", output);
  408.     fputs(" /adieresis /aring /ae /ccedilla /egrave /eacuten", output);
  409.     fputs(" /ecircumflex /edieresis /igrave /iacute /icircumflexn", output);
  410.     fputs(" /idieresis /eth /ntilde /ograve /oacute /ocircumflexn", output);
  411.     fputs(" /otilde /odieresis /divide /oslash /ugrave /uacuten", output);
  412.     fputs(" /ucircumflex /udieresis /yacute /thorn /ydieresisn", output);
  413.     fputs("]def{restore}ifn", output);
  414.     fputs(ISOprologue2, output);
  415. }
  417. static const char* defPrologue = "
  418. /Cols %u defn
  419. /PageWidth %.2f defn
  420. /PageHeight %.2f defn
  421. /LH %u defn
  422. /B{gsave}defn
  423. /LN{show}defn
  424. /EL{grestore 0 -%d rmoveto}defn
  425. /M{0 rmoveto}defn
  426. /O{gsave show grestore}defn
  427. /LandScape{90 rotate 0 -%ld translate}defn
  428. /U{%d mul}defn
  429. /UP{U 72 div}defn
  430. /S{show grestore 0 -%d rmoveto}defn
  431. ";
  433. static const char* headerPrologue1 = "
  434. /InitGaudyHeaders{n
  435.   /HeaderY exch def /BarLength exch defn
  436.   /ftD /Times-Bold findfont 12 UP scalefont defn
  437.   /ftF /Times-Roman findfont 14 UP scalefont defn
  438.   /ftP /Helvetica-Bold findfont 30 UP scalefont defn
  439.   /fillbox{ % w h x y => -n
  440.     moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineton
  441.     closepath filln
  442.   }defn
  443.   /LB{ % x y w h (label) font labelColor boxColor labelPtSize => -n
  444.     gsaven
  445.     /pts exch UP def /charcolor exch def /boxcolor exch defn
  446.     /font exch def /label exch defn
  447.     /h exch def /w exch defn
  448.     /y exch def /x exch defn
  449.     boxcolor setgray w h x y fillboxn
  450.     /lines label length defn
  451.     /ly y h add h lines pts mul sub 2 div sub pts .85 mul sub defn
  452.     font setfont charcolor setgrayn
  453.     label {n
  454.       dup stringwidth popn
  455.       2 div x w 2 div add exch sub ly moveton
  456.       shown
  457.       /ly ly pts sub defn
  458.     } foralln
  459.     grestoren
  460.   }defn
  461.   /Header{ % (file) [(date)] (page) => -n
  462.     /Page exch def /Date exch def /File exch defn
  463.     .25 U HeaderY U BarLength .1 sub U .25 U [File] ftF .97 0 14 LBn
  464.     .25 U HeaderY .25 add U BarLength .1 sub U .25 U [()] ftF 1 0 14 LBn
  465.     .25 U HeaderY U 1 U .5 U Date ftD .7 0 12 LBn
  466.     BarLength .75 sub U HeaderY U 1 U .5 U [Page] ftP .7 1 30 LBn
  467.     1 1 Cols 1 sub{n
  468.       BarLength Cols div mul .19 add U HeaderY U moveto 0 -10 U rlineto stroken
  469.     }forn
  470.   }defn
  471. }defn
  472. ";
  473. static const char* headerPrologue2 = "
  474. /InitNormalHeaders{n
  475.   /HeaderY exch def /BarLength exch defn
  476.   /ftF /Times-Roman findfont 14 UP scalefont defn
  477.   /ftP /Helvetica-Bold findfont 14 UP scalefont defn
  478.   /LB{ % x y w h (label) font labelColor labelPtSize => -n
  479.     gsaven
  480.     /pts exch UP def /charcolor exch defn
  481.     /font exch def /label exch defn
  482.     /h exch def /w exch defn
  483.     /y exch def /x exch defn
  484.     /ly y h add h pts sub 2 div sub pts .85 mul sub defn
  485.     font setfont charcolor setgrayn
  486.     label stringwidth pop 2 div x w 2 div add exch sub ly moveton
  487.     label shown
  488.     grestoren
  489.   }defn
  490.   /Header{ % (file) [(date)] (page) => -n
  491.     /Page exch def pop /File exch defn
  492.     .25 U HeaderY U BarLength 2 div U .5 U File ftF 0 14 LBn
  493.     BarLength .75 sub U HeaderY U 1 U .5 U Page ftP 0 14 LBn
  494.     1 1 Cols 1 sub{n
  495.       BarLength Cols div mul .19 add U HeaderY U moveto 0 -10 U rlineto stroken
  496.     }forn
  497.   }defn
  498. }defn
  499. /InitNullHeaders{/Header{3{pop}repeat}def pop pop}defn
  500. ";
  502. /*
  503.  * Emit the DSC header comments and prologue.
  504.  */
  505. void
  506. TextFormat::emitPrologue(void)
  507. {
  508.     fputs("%!PS-Adobe-3.0n", output);
  509.     fprintf(output, "%%%%Creator: HylaFAX TextFormat Classn");
  510.     fprintf(output, "%%%%Title: %sn", (const char*) title);
  511.     time_t t = Sys::now();
  512.     fprintf(output, "%%%%CreationDate: %s", ctime(&t));
  513.     char* cp = getlogin();
  514.     fprintf(output, "%%%%For: %sn", cp ? cp : "");
  515.     fputs("%%Origin: 0 0n", output);
  516.     fprintf(output, "%%%%BoundingBox: 0 0 %.0f %.0fn",
  517. physPageWidth*72, physPageHeight*72);
  518.     fputs("%%Pages: (atend)n", output);
  519.     fprintf(output, "%%%%PageOrder: %sn",
  520. reverse ? "Descend" : "Ascend");
  521.     fprintf(output, "%%%%Orientation: %sn",
  522. landscape ? "Landscape" : "Portrait");
  523.     fprintf(output, "%%%%DocumentNeededResources: font");
  524.     FontDictIter iter;
  525.     for (iter = *fonts; iter.notDone(); iter++) {
  526. TextFont* f = iter.value();
  527. fprintf(output, " %s", f->getFamily());
  528.     }
  529.     fputc('n', output);
  530.     if (gaudy) {
  531. fputs("%%+ font Times-Boldn", output);
  532. fputs("%%+ font Times-Romann", output);
  533. fputs("%%+ font Helvetica-Boldn", output);
  534.     }
  535.     emitClientComments(output);
  536.     fprintf(output, "%%%%EndCommentsn");
  538.     fprintf(output, "%%%%BeginPrologn");
  539.     fputs("/$printdict 50 dict def $printdict beginn", output);
  540.     if (useISO8859)
  541. putISOPrologue();
  542.     fprintf(output, defPrologue
  543. , numcol
  544. , CVTI(pageWidth - (lm+rm))
  545. , CVTI(pageHeight - (tm+bm))
  546. , lineHeight
  547. , lineHeight
  548. , pageHeight
  549. , LUNIT
  550. , lineHeight
  551.     );
  552.     fputs(headerPrologue1, output);
  553.     fputs(headerPrologue2, output);
  554.     fprintf(output, "%.2f %.2f Init%sHeadersn"
  555. , CVTI(pageWidth - (lm+rm))
  556. , CVTI(pageHeight - tm)
  557. , (gaudy ? "Gaudy" : headers ? "Normal" : "Null")
  558.     );
  559.     for (iter = *fonts; iter.notDone(); iter++)
  560. iter.value()->defFont(output, pointSize, useISO8859);
  561.     emitClientPrologue(output);
  562.     fputs("endn", output);
  563.     fputs("%%EndPrologn", output);
  564. }
  565. void TextFormat::emitClientComments(FILE*) {}
  566. void TextFormat::emitClientPrologue(FILE*) {}
  568. /*
  569.  * Emit the DSC trailer comments.
  570.  */
  571. void
  572. TextFormat::emitTrailer(void)
  573. {
  574.     fputs("%%Trailern", output);
  575.     fprintf(output, "%%%%Pages: %dn", pageNum - firstPageNum);
  576.     fputs("%%EOFn", output);
  577. }
  579. void
  580. TextFormat::newPage(void)
  581. {
  582.     x = lm; // x starts at left margin
  583.     right_x = col_width - col_margin/2; // right x, 0-relative
  584.     y = pageHeight - tm - lineHeight; // y at page top
  585.     level = 0; // string paren level reset
  586.     column = 1;
  587.     boc = true;
  588.     bop = true;
  589. }
  591. void
  592. TextFormat::newCol(void)
  593. {
  594.     x += col_width; // x, shifted
  595.     right_x += col_width; // right x, shifted
  596.     y = pageHeight - tm - lineHeight; // y at page top
  597.     level = 0;
  598.     column++;
  599.     boc = true;
  600. }
  602. static void
  603. putString(FILE* fd, const char* val)
  604. {
  605.     fputc('(', fd);
  606.     for (; *val; val++) {
  607. u_int c = *val & 0xff;
  608. if ((c & 0200) == 0) {
  609.     if (c == '(' || c == ')' || c == '\')
  610. fputc('\', fd);
  611.     fputc(c, fd);
  612. } else
  613.     fprintf(fd, "\%03o", c);
  614.     }
  615.     fputc(')', fd);
  616. }
  618. void
  619. TextFormat::beginCol(void)
  620. {
  621.     if (column == 1) { // new page
  622. if (reverse)  {
  623.     u_int k = pageNum-firstPageNum;
  624.     off_t off = (off_t) ftell(tf);
  625.     if (k < pageOff->length())
  626. (*pageOff)[k] = off;
  627.     else
  628. pageOff->append(off);
  629. }
  630. fprintf(tf,"%%%%Page: "%d" %dn", pageNum-firstPageNum+1, pageNum);
  631. fputs("save $printdict beginn", tf);
  632. fprintf(tf, ".05 dup scalen");
  633. curFont->setfont(tf);
  634. if (landscape)
  635.     fputs("LandScapen", tf);
  636. putString(tf, curFile);
  637. fputc('[', tf);
  638. putString(tf, modDate);
  639. putString(tf, modTime);
  640. fputc(']', tf);
  641. fprintf(tf, "(%d)Headern", pageNum);
  642.     }
  643.     fprintf(tf, "%ld %ld moveton",x,y);
  644. }
  646. void
  647. TextFormat::beginLine(void)
  648. {
  649.     if (boc)
  650. beginCol(), boc = false, bop = false;
  651.     fputc('B', tf);
  652. }
  654. void
  655. TextFormat::beginText(void)
  656. {
  657.     fputc('(', tf);
  658.     level++;
  659. }
  661. void
  662. TextFormat::hrMove(TextCoord x)
  663. {
  664.     fprintf(tf, " %ld M ", x);
  665.     xoff += x;
  666. }
  668. void
  669. TextFormat::closeStrings(const char* cmd)
  670. {
  671.     int l = level;
  672.     for (; level > 0; level--)
  673. fputc(')', tf);
  674.     if (l > 0)
  675. fputs(cmd, tf);
  676. }
  678. void
  679. TextFormat::beginFile(void)
  680. {
  681.     newPage(); // each file starts on a new page
  683.     bol = true; // force line start
  684.     bot = true; // force text start
  685.     xoff = col_width * (column-1);
  686. }
  688. void
  689. TextFormat::endFile(void)
  690. {
  691.     if (!bot)
  692. endTextLine();
  693.     if (!bol)
  694. endLine();
  695.     if (!bop) {
  696. column = numcol; // force page end action
  697. endTextCol();
  698.     }
  699.     if (reverse) {
  700. /*
  701.  * Normally, beginCol sets the pageOff entry.  Since this is
  702.  * the last output for this file, we must set it here manually.
  703.  * If more files are printed, this entry will be overwritten (with
  704.  * the same value) at the next call to beginCol.
  705.  */
  706. off_t off = (off_t) ftell(tf);
  707. pageOff->append(off);
  708.     }
  709. }
  711. void
  712. TextFormat::formatFile(const char* name)
  713. {
  714.     FILE* fp = fopen(name, "r");
  715.     if (fp != NULL) {
  716. curFile = name;
  717. formatFile(fp);
  718. fclose(fp);
  719.     } else
  720. error("%s: Cannot open file: %s", name, strerror(errno));
  721. }
  723. void
  724. TextFormat::formatFile(FILE* fp)
  725. {
  726. #if HAS_MMAP
  727.     struct stat sb;
  728.     Sys::fstat(fileno(fp), sb);
  729.     char* addr = (char*)
  730. mmap(NULL, (size_t) sb.st_size, PROT_READ, MAP_SHARED, fileno(fp), 0);
  731.     if (addr == (char*) -1) { // revert to file reads
  732. #endif
  733. int c;
  734. while ((c = getc(fp)) == 'f') // discard initial form feeds
  735.     ;
  736. ungetc(c, fp);
  737. beginFile();
  738. format(fp);
  739. endFile();
  740. #if HAS_MMAP
  741.     } else {
  742. const char* cp = addr;
  743. const char* ep = cp + sb.st_size;
  744. while (cp < ep && *cp == 'f') // discard initial form feeds
  745.     cp++;
  746. beginFile();
  747. format(cp, ep-cp);
  748. endFile();
  749. munmap(addr, (size_t) sb.st_size);
  750.     }
  751. #endif
  752. }
  754. void
  755. TextFormat::format(FILE* fp)
  756. {
  757.     int c;
  758.     while ((c = getc(fp)) != EOF) {
  759. switch (c) {
  760. case '': // discard nulls
  761.     break;
  762. case 'f': // form feed
  763.     if (!bop) {
  764. endTextCol();
  765. bol = bot = true;
  766.     }
  767.     break;
  768. case 'n': // line break
  769.     if (bol)
  770. beginLine();
  771.     if (bot)
  772. beginText();
  773.     endTextLine();
  774.     break;
  775. case 'r': // check for overstriking
  776.     if ((c = getc(fp)) == 'n') {
  777. ungetc(c,fp); // collapse rn => n
  778. break;
  779.     }
  780.     closeStrings("On"); // do overstriking
  781.     bot = true; // start new string
  782.     break;
  783. default:
  784.     TextCoord hm;
  785.     if (c == 't' || c == ' ') {
  786. /*
  787.  * Coalesce white space into one relative motion.
  788.  * The offset calculation below is to insure that
  789.  * 0 means the start of the line (no matter what
  790.  * column we're in).
  791.  */
  792. hm = 0;
  793. int cc = c;
  794. TextCoord off = xoff - col_width*(column-1);
  795. do {
  796.     if (cc == 't')
  797. hm += tabWidth - (off+hm) % tabWidth;
  798.     else
  799. hm += curFont->charwidth(' ');
  800. } while ((cc = getc(fp)) == 't' || cc == ' ');
  801. if (cc != EOF)
  802.     ungetc(cc, fp);
  803. /*
  804.  * If the motion is one space's worth, either
  805.  * a single blank or a tab that causes a blank's
  806.  * worth of horizontal motion, then force it
  807.  * to be treated as a blank below.
  808.  */
  809. if (hm == curFont->charwidth(' '))
  810.     c = ' ';
  811. else
  812.     c = 't';
  813.     } else
  814. hm = curFont->charwidth(c);
  815.     if (xoff + hm > right_x) {
  816. if (!wrapLines) // discard line overflow
  817.     break;
  818. if (c == 't') // adjust white space motion
  819.     hm -= right_x - xoff;
  820. endTextLine();
  821.     }
  822.     if (bol)
  823. beginLine(), bol = false;
  824.     if (c == 't') { // close open PS string and do motion
  825. if (hm > 0) {
  826.     closeStrings("LN");
  827.     bot = true; // force new string
  828.     hrMove(hm);
  829. }
  830.     } else { // append to open PS string
  831. if (bot)
  832.     beginText(), bot = false;
  833. if (040 <= c && c <= 0176) {
  834.     if (c == '(' || c == ')' || c == '\')
  835. fputc('\',tf);
  836.     fputc(c,tf);
  837. } else
  838.     fprintf(tf, "\%03o", c & 0xff);
  839. xoff += hm;
  840.     }
  841.     break;
  842. }
  843.     }
  844. }
  846. void
  847. TextFormat::format(const char* cp, u_int cc)
  848. {
  849.     const char* ep = cp+cc;
  850.     while (cp < ep) {
  851. int c = *cp++ & 0xff;
  852. switch (c) {
  853. case '': // discard nulls
  854.     break;
  855. case 'f': // form feed
  856.     if (!bop) {
  857. endTextCol();
  858. bol = bot = true;
  859.     }
  860.     break;
  861. case 'n': // line break
  862.     if (bol)
  863. beginLine();
  864.     if (bot)
  865. beginText();
  866.     endTextLine();
  867.     break;
  868. case 'r': // check for overstriking
  869.     if (cp < ep && *cp == 'n')
  870. break; // collapse rn => n
  871.     cp++; // count character
  872.     closeStrings("On"); // do overstriking
  873.     bot = true; // start new string
  874.     break;
  875. default:
  876.     TextCoord hm;
  877.     if (c == 't' || c == ' ') {
  878. /*
  879.  * Coalesce white space into one relative motion.
  880.  * The offset calculation below is to insure that
  881.  * 0 means the start of the line (no matter what
  882.  * column we're in).
  883.  */
  884. hm = 0;
  885. int cc = c;
  886. TextCoord off = xoff - col_width*(column-1);
  887. do {
  888.     if (cc == 't')
  889. hm += tabWidth - (off+hm) % tabWidth;
  890.     else
  891. hm += curFont->charwidth(' ');
  892. } while (cp < ep && ((cc = *cp++) == 't' || cc == ' '));
  893. if (cc != 't' && cc != ' ')
  894.     cp--;
  895. /*
  896.  * If the motion is one space's worth, either
  897.  * a single blank or a tab that causes a blank's
  898.  * worth of horizontal motion, then force it
  899.  * to be treated as a blank below.
  900.  */
  901. if (hm == curFont->charwidth(' '))
  902.     c = ' ';
  903. else
  904.     c = 't';
  905.     } else
  906. hm = curFont->charwidth(c);
  907.     if (xoff + hm > right_x) {
  908. if (!wrapLines) // discard line overflow
  909.     break;
  910. if (c == 't') // adjust white space motion
  911.     hm -= right_x - xoff;
  912. endTextLine();
  913.     }
  914.     if (bol)
  915. beginLine(), bol = false;
  916.     if (c == 't') { // close open PS string and do motion
  917. if (hm > 0) {
  918.     closeStrings("LN");
  919.     fprintf(tf, " %ld M ", hm);
  920.     bot = true; // force new string
  921. }
  922.     } else { // append to open PS string
  923. if (bot)
  924.     beginText(), bot = false;
  925. if (040 <= c && c <= 0176) {
  926.     if (c == '(' || c == ')' || c == '\')
  927. fputc('\',tf);
  928.     fputc(c,tf);
  929. } else
  930.     fprintf(tf, "\%03o", c & 0xff);
  931.     }
  932.     xoff += hm;
  933.     break;
  934. }
  935.     }
  936. }
  938. static const char* outlineCol = "n
  939. gsave
  940.     %ld setlinewidth
  941.     newpath %ld %ld moveto
  942.     %ld %ld rlineto
  943.     %ld %ld rlineto
  944.     %ld %ld rlineto
  945.     closepath stroke 
  946. grestoren
  947. ";
  949. void
  950. TextFormat::endCol(void)
  951. {
  952.     if (outline > 0) {
  953. fprintf(tf, outlineCol, outline,
  954.     x - col_margin, bm, col_width, 0, 0,
  955.     pageHeight-bm-tm, -col_width, 0);
  956.     }
  957.     if (column == numcol) { // columns filled, start new page
  958. if (!bop) {
  959.     pageNum++;
  960.     fputs("showpagenend restoren", tf);
  961.     flush();
  962.     newPage();
  963. }
  964.     } else
  965. if (!boc)
  966.     newCol();
  967. }
  969. void
  970. TextFormat::endPage(void)
  971. {
  972.     column = numcol;
  973.     endCol();
  974. }
  976. void
  977. TextFormat::endLine(void)
  978. {
  979.     fputs("ELn", tf);
  980.     if ((y -= lineHeight) < bm)
  981. endCol();
  982.     xoff = col_width * (column-1);
  983. }
  985. void
  986. TextFormat::endTextCol(void)
  987. {
  988.     closeStrings("LN");
  989.     fputc('n', tf);
  990.     endCol();
  991. }
  993. void
  994. TextFormat::endTextLine(void)
  995. {
  996.     closeStrings("Sn");
  997.     if ((y -= lineHeight) < bm)
  998. endCol();
  999.     xoff = col_width * (column-1);
  1000.     bol = bot = true;
  1001. }
  1003. void
  1004. TextFormat::reserveVSpace(TextCoord vs)
  1005. {
  1006.     if (y - vs < bm)
  1007. endCol();
  1008. }
  1010. void
  1011. TextFormat::flush(void)
  1012. {
  1013.     fflush(tf);
  1014.     if (ferror(tf) && errno == ENOSPC)
  1015. fatal("Output write error: %s", strerror(errno));
  1016. }
  1018. /*
  1019.  * Convert a value of the form:
  1020.  *  #.##bp big point (1in = 72bp)
  1021.  *  #.##cc cicero (1cc = 12dd)
  1022.  *  #.##cm centimeter
  1023.  *  #.##dd didot point (1157dd = 1238pt)
  1024.  *  #.##in inch
  1025.  *  #.##mm millimeter (10mm = 1cm)
  1026.  *  #.##pc pica (1pc = 12pt)
  1027.  *  #.##pt point (72.27pt = 1in)
  1028.  *  #.##sp scaled point (65536sp = 1pt)
  1029.  * to inches, returning it as the function value.  The case of
  1030.  * the dimension name is ignored.  No space is permitted between
  1031.  * the number and the dimension.
  1032.  */
  1033. TextCoord
  1034. TextFormat::inch(const char* s)
  1035. {
  1036.     char* cp;
  1037.     double v = strtod(s, &cp);
  1038.     if (cp == NULL)
  1039. return (ICVT(0)); // XXX
  1040.     if (strncasecmp(cp,"in",2) == 0) // inches
  1041. ;
  1042.     else if (strncasecmp(cp,"cm",2) == 0) // centimeters
  1043. v /= 2.54;
  1044.     else if (strncasecmp(cp,"pt",2) == 0) // points
  1045. v /= 72.27;
  1046.     else if (strncasecmp(cp,"cc",2) == 0) // cicero
  1047. v *= 12.0 * (1238.0 / 1157.0) / 72.27;
  1048.     else if (strncasecmp(cp,"dd",2) == 0) // didot points
  1049. v *= (1238.0 / 1157.0) / 72.27;
  1050.     else if (strncasecmp(cp,"mm",2) == 0) // millimeters
  1051. v /= 25.4;
  1052.     else if (strncasecmp(cp,"pc",2) == 0) // pica
  1053. v *= 12.0 / 72.27;
  1054.     else if (strncasecmp(cp,"sp",2) == 0) // scaled points
  1055. v /= (65536.0 * 72.27);
  1056.     else // big points
  1057. v /= 72.0;
  1058.     return ICVT(v);
  1059. }
  1061. /*
  1062.  * Configuration file support.
  1063.  */
  1064. void
  1065. TextFormat::setupConfig()
  1066. {
  1067.     gaudy = false; // emit gaudy headers
  1068.     landscape = false; // horizontal landscape mode output
  1069.     useISO8859 = true; // use the ISO 8859-1 character encoding
  1070.     reverse = false; // page reversal flag
  1071.     wrapLines = true; // wrap/truncate lines
  1072.     headers = true; // emit page headers
  1074.     pointSize = -1; // font point size in big points
  1075.     lm = inch("0.25in"); // left margin
  1076.     rm = inch("0.25in"); // right margin
  1077.     tm = inch("0.85in"); // top margin
  1078.     bm = inch("0.5in"); // bottom margin
  1079.     lineHeight = 0; // inter-line spacing
  1080.     numcol = 1; // number of text columns
  1081.     col_margin = 0L; // inter-column margin
  1082.     outline = 0L; // page and column outline linewidth
  1083.     tabStop = 8; // 8-column tab stop
  1084.     setPageSize("default"); // default system page dimensions
  1085. }
  1087. void
  1088. TextFormat::resetConfig()
  1089. {
  1090.     setupConfig();
  1091. }
  1093. void TextFormat::configError(const char* ...) {}
  1094. void TextFormat::configTrace(const char* ...) {}
  1096. #undef streq
  1097. #define streq(a,b) (strcasecmp(a,b)==0)
  1099. bool
  1100. TextFormat::setConfigItem(const char* tag, const char* value)
  1101. {
  1102.     if (streq(tag, "columns"))
  1103. setNumberOfColumns(getNumber(value));
  1104.     else if (streq(tag, "pageheaders"))
  1105. setPageHeaders(getBoolean(value));
  1106.     else if (streq(tag, "linewrap"))
  1107. setLineWrapping(getBoolean(value));
  1108.     else if (streq(tag, "iso8859"))
  1109. setISO8859(getBoolean(value));
  1110.     else if (streq(tag, "textfont"))
  1111. setTextFont(value);
  1112.     else if (streq(tag, "gaudyheaders"))
  1113. setGaudyHeaders(getBoolean(value));
  1114.     else if (streq(tag, "pagemargins"))
  1115. setPageMargins(value);
  1116.     else if (streq(tag, "outlinemargin"))
  1117. setOutlineMargin(inch(value));
  1118.     else if (streq(tag, "textpointsize"))
  1119. setTextPointSize(inch(value));
  1120.     else if (streq(tag, "orientation"))
  1121. setPageOrientation(streq(value, "landscape") ? LANDSCAPE : PORTRAIT);
  1122.     else if (streq(tag, "pagesize"))
  1123. setPageSize(value);
  1124.     else if (streq(tag, "pagewidth"))
  1125. setPageWidth(atof(value));
  1126.     else if (streq(tag, "pageheight"))
  1127. setPageHeight(atof(value));
  1128.     else if (streq(tag, "pagecollation"))
  1129. setPageCollation(streq(value, "forward") ? FORWARD : REVERSE);
  1130.     else if (streq(tag, "textlineheight"))
  1131. setTextLineHeight(inch(value));
  1132.     else if (streq(tag, "tabstop"))
  1133. tabStop = getNumber(value);
  1134.     else if (streq(tag, "fontmap")) // XXX
  1135. TextFont::fontMap = value;
  1136.     else if (streq(tag, "fontpath"))
  1137. setFontPath(value);
  1138.     else
  1139. return (false);
  1140.     return (true);
  1141. }
  1143. #define NCHARS (sizeof (widths) / sizeof (widths[0]))
  1145. fxStr TextFont::fontMap = _PATH_FONTMAP;
  1146. fxStr TextFont::fontPath = _PATH_AFM;
  1147. u_int TextFont::fontID = 0;
  1149. TextFont::TextFont(const char* cp) : family(cp)
  1150. {
  1151.     showproc = fxStr::format("s%u", fontID);
  1152.     setproc = fxStr::format("sf%u", fontID);
  1153.     fontID++;
  1154. }
  1155. TextFont::~TextFont() {}
  1157. bool
  1158. TextFont::decodeFontName(const char* name, fxStr& filename, fxStr& emsg)
  1159. {
  1160.     struct stat junk;
  1161.     fxStr path = fontMap;
  1162.     u_int index = path.next(0, ':');
  1163.     fxStr key = name;
  1164.     while (index > 0) {
  1166.         /* Newer versions of Ghostscript use "Fontmap.GS"
  1167.          * whereas older ones omit the ".GS" extension.
  1168.          * If the Fontmap.GS file isn't available default
  1169.          * to the older convention.
  1170.          */
  1171.         filename = path.head(index) | "/" | "Fontmap.GS";
  1172.         if (stat(filename, &junk) != 0)
  1173.             filename = path.head(index) | "/" | "Fontmap";
  1174.         fxStr fontMapFile = filename;
  1176.         path.remove(0, index);
  1177.         if (path.length() > 0) path.remove(0, 1);
  1178.         FILE* fd = Sys::fopen(fontMapFile, "r");
  1179.         if (fd != NULL && fontMapFile[0] == '/') {
  1180.             char buf[1024];
  1181.     int aliascount = maxaliases;
  1182.             while (fgets(buf, sizeof(buf), fd) != NULL &&
  1183. aliascount > 0) {
  1184.                 size_t len = strcspn(buf, "%n");
  1185.                 if (len == strlen(buf)) {
  1186.             emsg = fxStr::format(
  1187.                 "Warning:%s - line too long.", (const char*)fontMapFile);
  1188.                 break;
  1189.                 }
  1190.         if (len == 0) continue;
  1191.                 *(buf + len) = '';
  1192.                 char* tmp = buf + strcspn(buf, ") t");
  1193.                 *tmp++ = '';
  1194.                 tmp += strspn(tmp, " t");
  1195.                 if (strcmp(key, buf + 1) == 0) {
  1196.                     //match - now ensure it is the last one in the file
  1197.     // for gs compatibility
  1198.                     *(tmp + strcspn(tmp, ") t;")) = '';
  1199.                     fxStr val = tmp;
  1200.                     while (fgets(buf, sizeof(buf), fd) != NULL) {
  1201.                         len = strcspn(buf, "%n");
  1202.                         *(buf + len) = '';
  1203.                         if (len == strlen(buf)) {
  1204.                     emsg = fxStr::format(
  1205.                 "Warning: %s - line too long.", (const char*) fontMapFile);
  1206.                     break;
  1207.                         }
  1208. if (len == 0) continue;
  1209.                 tmp = buf + strcspn(buf, ") t");
  1210.         *tmp++ = '';
  1211.                         tmp += strspn(tmp, " t");
  1212.                         if (strcmp(key, buf + 1) == 0) {
  1213.                             *(tmp + strcspn(tmp, ") t;")) = '';
  1214.                             val = tmp;
  1215. }
  1216.     }
  1217.                     if (val[0] == '/') {
  1218.         //alias
  1219.                 aliascount--;
  1220. val.remove(0);
  1221.         key = val;
  1222.          fseek(fd, 0L, SEEK_SET);
  1223.                     } else {
  1224.                         //real file
  1225. key = name;
  1226.                         fclose(fd);
  1227. val.remove(0);
  1228. int pos = val.next(0, '.');
  1229. val.remove(pos, val.length() - pos);
  1230. val.append(".afm");
  1231. //move through dirs looking for font
  1232. fxStr fpath = fontPath;
  1233.                         int index2 = fpath.next(0, ':');
  1234.                         filename = fpath.head(index2) | "/" | val;
  1235.                         fpath.remove(0, index2);
  1236.      if (fpath.length() > 0) fpath.remove(0, 1);
  1237. while (stat(filename, &junk) != 0 && index2 > 0) {
  1238.                             index2 = fpath.next(0, ':');
  1239.                             filename = fpath.head(index2) | "/" | val;
  1240.                             fpath.remove(0, index2);
  1241.          if (fpath.length() > 0) fpath.remove(0, 1);
  1242. }
  1243. bool result = stat(filename, &junk) ? false : true;
  1244. if (!result)
  1245.                     emsg = fxStr::format(
  1246.         "Warning: %s invalid Fontmap entry - no filename present", (const char*)val);
  1247.                         return result;
  1248.                     }
  1249.                 }
  1250.             }
  1251.             fclose(fd);
  1252.         }
  1253.         index = path.next(0, ':');
  1254.     }
  1255.     //decoding using fontmap has failed
  1256.     //now try plain filename with/without afm extension
  1257.     path = fontPath;
  1258.     index = path.next(0, ':');
  1259.     while (index > 0) {
  1260.         filename = path.head(index) | "/" | key | ".afm";
  1261.         path.remove(0, index);
  1262.         if (path.length() > 0) path.remove(0, 1);
  1263.         if (stat(filename, &junk) == 0) return true;
  1264. filename.resize(filename.length()-4); // strip ``.afm''
  1265.         if (stat(filename, &junk) == 0) return true;
  1266.         index = path.next(0, ':');
  1267.     }
  1268.     return false;
  1269. }
  1271. bool
  1272. TextFont::findFont(const char* name)
  1273. {
  1274.     fxStr myname, emsg;
  1275.     return decodeFontName(name, myname, emsg);
  1276. }
  1278. static const char* defISOFont = "
  1279. /%s{/%s findfont
  1280.   findISO{reencodeISO /%s-ISO exch definefont}if
  1281.   %d UP scalefont setfont
  1282. }defn
  1283. ";
  1284. static const char* defRegularFont = "
  1285. /%s{/%s findfont %d UP scalefont setfont}defn
  1286. ";
  1288. void
  1289. TextFont::defFont(FILE* fd, TextCoord ps, bool useISO8859) const
  1290. {
  1291.     if (useISO8859) {
  1292. fprintf(fd, defISOFont, (const char*) setproc,
  1293.     (const char*) family, (const char*) family, ps/20, ps/20); 
  1294.     } else {
  1295. fprintf(fd, defRegularFont, (const char*) setproc,
  1296.     (const char*) family, ps/20);
  1297.     }
  1298.     fprintf(fd, "/%s{%s show}defn",
  1299. (const char*) showproc, (const char*) setproc);
  1300. }
  1302. void
  1303. TextFont::setfont(FILE* fd) const
  1304. {
  1305.     fprintf(fd, " %s ", (const char*) setproc);
  1306. }
  1308. TextCoord
  1309. TextFont::show(FILE* fd, const char* val, int len) const
  1310. {
  1311.     TextCoord hm = 0;
  1312.     if (len > 0) {
  1313. fprintf(fd, "(");
  1314. do {
  1315.     u_int c = *val++ & 0xff;
  1316.     if ((c & 0200) == 0) {
  1317. if (c == '(' || c == ')' || c == '\')
  1318.     fputc('\', fd);
  1319. fputc(c, fd);
  1320.     } else
  1321. fprintf(fd, "\%03o", c);
  1322.     hm += widths[c]; // Leif Erlingsson <leif@lege.com>
  1323. } while (--len);
  1324. fprintf(fd, ")%s ", (const char*) showproc);
  1325.     }
  1326.     return (hm);
  1327. }
  1329. TextCoord
  1330. TextFont::show(FILE* fd, const fxStr& s) const
  1331. {
  1332.     return show(fd, s, s.length());
  1333. }
  1335. TextCoord
  1336. TextFont::strwidth(const char* cp) const
  1337. {
  1338.     TextCoord w = 0;
  1339.     while (*cp)
  1340. w += widths[(unsigned) (*cp++ & 0xff)]; // Leif Erlingsson <leif@lege.com>
  1341.     return w;
  1342. }
  1344. void
  1345. TextFont::loadFixedMetrics(TextCoord w)
  1346. {
  1347.     for (u_int i = 0; i < NCHARS; i++)
  1348. widths[i] = w;
  1349. }
  1351. bool
  1352. TextFont::getAFMLine(FILE* fp, char* buf, int bsize)
  1353. {
  1354.     if (fgets(buf, bsize, fp) == NULL)
  1355. return (false);
  1356.     char* cp = strchr(buf, 'n');
  1357.     if (cp == NULL) { // line too long, skip it
  1358. int c;
  1359. while ((c = getc(fp)) != 'n') // skip to end of line
  1360.     if (c == EOF)
  1361. return (false);
  1362. cp = buf; // force line to be skipped
  1363.     }
  1364.     *cp = '';
  1365.     return (true);
  1366. }
  1368. FILE*
  1369. TextFont::openAFMFile(fxStr& fontpath)
  1370. {
  1371.     fxStr emsg;
  1372.     if (!decodeFontName(family, fontpath, emsg)) {
  1373. fprintf(stderr,emsg);
  1374.         return NULL;
  1375.     } 
  1376.     return Sys::fopen(fontpath, "r");
  1377. }
  1379. bool
  1380. TextFont::readMetrics(TextCoord ps, bool useISO8859, fxStr& emsg)
  1381. {
  1382.     fxStr file;
  1383.     FILE *fp = openAFMFile(file);
  1384.     if (fp == NULL) {
  1385. emsg = fxStr::format(
  1386.     "%s: Can not open font metrics file; using fixed widths",
  1387.     (const char*) file);
  1388. loadFixedMetrics(625*ps/1000L); // NB: use fixed width metrics
  1389. return (false);
  1390.     }
  1391.     /*
  1392.      * Since many ISO-encoded fonts don't include metrics for
  1393.      * the higher-order characters we cheat here and use a
  1394.      * default metric for those glyphs that were unspecified.
  1395.      */
  1396.     loadFixedMetrics(useISO8859 ? 625*ps/1000L : 0);
  1398.     char buf[1024];
  1399.     u_int lineno = 0;
  1400.     do {
  1401. if (!getAFMLine(fp, buf, sizeof (buf))) {
  1402.     emsg = fxStr::format(
  1403. "%s: No glyph metric table located; using fixed widths",
  1404. (const char*) file);
  1405.     fclose(fp);
  1406.     /*
  1407.      * Next line added by Leif Erlingsson <leif@lege.com> because
  1408.      * otherwise, if the metrics-file has no glyph metric table
  1409.      * and useISO8859 == False, the FixedMetrics will be all 0's!
  1410.      * (I don't know if this does or does not cause any problem.)
  1411.      */
  1412.     loadFixedMetrics(625*ps/1000L); // NB: use fixed width metrics
  1413.     return (false);
  1414. }
  1415. lineno++;
  1416.     } while (strncmp(buf, "StartCharMetrics", 16));
  1417.     while (getAFMLine(fp, buf, sizeof (buf)) && strcmp(buf, "EndCharMetrics")) {
  1418. lineno++;
  1419. int ix, w;
  1420. /* read the glyph position and width */
  1421. if (sscanf(buf, "C %d ; WX %d ;", &ix, &w) != 2) {
  1422.     emsg = fxStr::format("%s, line %u: format error",
  1423. (const char*) file, lineno);
  1424.     fclose(fp);
  1425.     return (false);
  1426. }
  1427. if (ix == -1) // end of unencoded glyphs
  1428.     break;
  1429. /*
  1430.  * Next if-clause added by Leif Erlingsson <leif@lege.com> because
  1431.  * experience has shown most glyph metric table's to be useless
  1432.  * for obtaining character widths of iso8859-1 characters > 127.
  1433.  * The Adobe Helvetica-Oblique metrics-file created Tue Apr 1
  1434.  * 12:54:09 PST 1986 caused bad spacing for eight-bit iso-8859-1
  1435.  * characters, for example.
  1436.  */
  1437. if (ix > 127)
  1438.     w = 625; // distrust metrics-file for char > 127
  1439. if ((unsigned)ix < NCHARS)
  1440.     widths[ix] = w*ps/1000L;
  1441.     }
  1442.     fclose(fp);
  1443.     return (true);
  1444. }