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

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

传真(Fax)编程

开发平台：

C/C++

PCFFont.c++：源码内容
  1. /* $Id: PCFFont.c++,v 1.5 2008/04/26 22:34:28 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1994-1996 Sam Leffler
  4.  * Copyright (c) 1994-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.  * Read and render a PCF font.  This code is VERY distantly
  29.  * related to the X11R5 code found in the file pcfread.c (the
  30.  * original copyright is at the bottom of this file).
  31.  *
  32.  * This code is specifically written to handle just enough
  33.  * of the format to image text for outgoing facsimile.
  34.  */
  35. #include <unistd.h>
  36. #include <stdlib.h>
  37. #include "PCFFont.h"
  38. #include "tiffio.h"
  40. #define LSBFirst 0
  41. #define MSBFirst 1
  43. struct PCFTableRec { // on-disk table of contents
  44.     u_long type;
  45.     u_long format;
  46.     u_long size;
  47.     u_long offset;
  48. };
  50. struct charInfo {
  51.     short lsb, rsb; // left+right side bearing from file
  52.     short ascent, descent;// ascent+descent from file
  53.     u_short cw; // character width from file
  54.     u_char* bits; // pointer to glyph bitmap
  55. };
  57. #define PCF_FILE_VERSION (('p'<<24)|('c'<<16)|('f'<<8)|1)
  58. #define PCF_FORMAT_MASK 0xffffff00
  60. #define PCF_DEFAULT_FORMAT 0x00000000
  61. #define PCF_COMPRESSED_METRICS 0x00000100
  62. #define PCF_ACCEL_W_INKBOUNDS 0x00000100
  64. #define PCF_METRICS (1<<2) // font metric information
  65. #define PCF_BITMAPS (1<<3) // glyph bitmaps
  66. #define PCF_BDF_ENCODINGS (1<<5) // BDF-based encoding
  67. #define PCF_BDF_ACCELERATORS (1<<8) // BDF-derived accelerator information
  69. #define PCF_GLYPH_PAD_MASK (3<<0)
  70. #define PCF_BYTE_MASK (1<<2)
  71. #define PCF_BIT_MASK (1<<3)
  72. #define PCF_SCAN_UNIT_MASK (3<<4)
  74. #define CONFIG_BIT MSBFirst // required bit order
  75. #define CONFIG_BYTE MSBFirst // required byte order
  76. #define CONFIG_GLYPH 2 // glyphs must be word-aligned
  77. #define CONFIG_GLYPH_IX 1 // index for word-aligned glyphs
  79. inline bool PCFFont::isFormat(u_long f) const
  80.     { return ((format&PCF_FORMAT_MASK) == f); }
  81. inline u_int PCFFont::byteOrder() const
  82.     { return ((format&PCF_BYTE_MASK) ? MSBFirst : LSBFirst); }
  83. inline u_int PCFFont::bitOrder() const
  84.     { return ((format&PCF_BIT_MASK) ? MSBFirst : LSBFirst); }
  85. inline u_int PCFFont::glyphPadIndex() const
  86.     { return ((format) & PCF_GLYPH_PAD_MASK); }
  87. inline u_int PCFFont::glyphPad() const
  88.     { return (1<<glyphPadIndex()); }
  89. inline u_int PCFFont::scanUnit() const
  90.     { return (1<<((format) & PCF_SCAN_UNIT_MASK)); }
  92. PCFFont::PCFFont()
  93. {
  94.     file = NULL;
  95.     filename = NULL;
  96.     encoding = NULL;
  97.     bitmaps = NULL;
  98.     metrics = NULL;
  99.     toc = NULL;
  100.     cdef = NULL;
  101.     { union { int32 i; char c[4]; } u; u.i = 1; isBigEndian = u.c[0] == 0; }
  102. }
  104. PCFFont::~PCFFont()
  105. {
  106.     cleanup();
  107. }
  109. void
  110. PCFFont::cleanup()
  111. {
  112.     if (file != NULL)
  113. fclose(file), file = NULL;
  114.     ready = false;
  115.     delete toc, toc = NULL;
  116.     delete encoding, encoding = NULL;
  117.     delete bitmaps, bitmaps = NULL;
  118.     delete metrics, metrics = NULL;
  119.     cdef = NULL;
  120. }
  122. /*
  123.  * Read only the useful bits from a PCF font file:
  124.  * font metrics, font bitmaps, font encoding, and
  125.  * some of the accelerator info.
  126.  */
  127. bool
  128. PCFFont::read(const char* name)
  129. {
  130.     cleanup();
  131.     filename = name; // for error diagnostics
  132.     file = fopen(filename, "r");
  133.     if (file == NULL) {
  134. error("Can not open file");
  135. return (false);
  136.     }
  137.     if (!readTOC())
  138. return (false);
  139.     if (seekToTable(PCF_METRICS)) {
  140. format = getLSB32();
  141. if (isFormat(PCF_DEFAULT_FORMAT))
  142.     numGlyphs = getINT32();
  143. else if (isFormat(PCF_COMPRESSED_METRICS))
  144.     numGlyphs = getINT16();
  145. else {
  146.     error("Bad font metric format 0x%lx", format);
  147.     return (false);
  148. }
  149. metrics = new charInfo[numGlyphs];
  150. if (!metrics) {
  151.     error("No space for font metric information");
  152.     return (false);
  153. }
  154. for (u_int i = 0; i < numGlyphs; i++) {
  155.     if (isFormat(PCF_DEFAULT_FORMAT))
  156. getMetric(metrics[i]);
  157.     else
  158. getCompressedMetric(metrics[i]);
  159. }
  160.     } else {
  161. error("Can not seek to font metric information");
  162. return (false);
  163.     }
  165.     if (seekToTable(PCF_BITMAPS)) {
  166. format = getLSB32();
  167. if (!isFormat(PCF_DEFAULT_FORMAT)) {
  168.     error("Bad bitmap data format 0x%lx", format);
  169.     return (false);
  170. }
  171. u_long nbitmaps = getINT32();
  172. u_long* offsets = new u_long[nbitmaps];
  173. if (!offsets) {
  174.     error("No space for bitmap offsets array");
  175.     return (false);
  176. }
  177. for (u_int i = 0; i < nbitmaps; i++)
  178.     offsets[i] = getINT32();
  179. u_long bitmapSizes[4];
  180. bitmapSizes[0] = getINT32();
  181. bitmapSizes[1] = getINT32();
  182. bitmapSizes[2] = getINT32();
  183. bitmapSizes[3] = getINT32();
  184. u_long sizebitmaps = bitmapSizes[glyphPadIndex()];
  185. bitmaps = new u_char[sizebitmaps];
  186. if (!bitmaps) {
  187.     error("No space for bitmap data array");
  188.     delete offsets;
  189.     return (false);
  190. }
  191. if (fread(bitmaps, (u_int) sizebitmaps, 1, file) != 1) {
  192.     error("Error reading bitmap data");
  193.     delete offsets;
  194.     return (false);
  195. }
  196. if (bitOrder() != CONFIG_BIT)
  197.     TIFFReverseBits(bitmaps, sizebitmaps);
  198. if (byteOrder() != bitOrder()) {
  199.     switch (scanUnit()) {
  200.     case 2:
  201. TIFFSwabArrayOfShort((uint16*) bitmaps, sizebitmaps/2);
  202. break;
  203.     case 4:
  204. TIFFSwabArrayOfLong((uint32*) bitmaps, sizebitmaps/4);
  205. break;
  206.     default:
  207. error("Unknown scan unit format %dn", scanUnit());
  208. break;
  209.     }
  210. }
  211. if (!isBigEndian) // NB: rasterizer requires BE byte order
  212.     TIFFSwabArrayOfShort((u_short*) bitmaps, sizebitmaps/2);
  213. if (glyphPad() != CONFIG_GLYPH) {
  214.     u_long sizepadbitmaps = bitmapSizes[CONFIG_GLYPH_IX];
  215.     u_char* padbitmaps = new u_char[sizepadbitmaps];
  216.     if (!padbitmaps) {
  217. error("No space for padded bitmap data array");
  218. delete offsets;
  219. return (false);
  220.     }
  221.     int newoff = 0;
  222.     for (u_int i = 0; i < nbitmaps; i++) {
  223. off_t old = offsets[i];
  224. offsets[i] = newoff;
  225. const charInfo& metric = metrics[i];
  226. newoff += repadBitmap(bitmaps + old, padbitmaps + newoff,
  227.   glyphPad(), CONFIG_GLYPH,
  228.   metric.rsb - metric.lsb,
  229.   metric.ascent + metric.descent);
  230.     }
  231.     delete bitmaps;
  232.     bitmaps = padbitmaps;
  233. }
  234. for (u_int j = 0; j < nbitmaps; j++) {
  235.     metrics[j].bits = bitmaps + offsets[j];
  236.     if ((unsigned long) metrics[j].bits & 1) {
  237. error("Internal error, bitmap data not word-aligned");
  238. delete offsets;
  239. return (false);
  240.     }
  241. }
  242. delete offsets;
  243.     } else {
  244. error("Can not seek to bitmap data");
  245. return (false);
  246.     }
  248.     if (seekToTable(PCF_BDF_ENCODINGS)) {
  249. format = getLSB32();
  250. if (!isFormat(PCF_DEFAULT_FORMAT)) {
  251.     error("Bad encodings format 0x%lx", format);
  252.     return (false);
  253. }
  254. firstCol = getINT16();
  255. lastCol = getINT16();
  256. firstRow = getINT16();
  257. lastRow = getINT16();
  258. u_short defaultCh = getINT16();
  260. u_int nencoding = (lastCol-firstCol+1) * (lastRow-firstRow+1);
  261. encoding = new charInfo*[nencoding];
  262. if (!encoding) {
  263.     error("No space for character encoding vector");
  264.     return (false);
  265. }
  266. for (u_int i = 0; i < nencoding; i++) {
  267.     int encodingOffset = getINT16();
  268.     encoding[i] = (encodingOffset == 0xffff) ?
  269. 0 : metrics + encodingOffset;
  270. }
  271. if (defaultCh != (u_short)-1) {
  272.     int r = defaultCh >> 8;
  273.     int c = defaultCh & 0xff;
  274.     if (firstRow <= r && r <= lastRow && firstCol <= c && c <= lastCol) {
  275. int cols = lastCol - firstCol + 1;
  276. r = r - firstRow;
  277. c = c - firstCol;
  278. cdef = encoding[r * cols + c];
  279.     }
  280. }
  281.     } else {
  282. error("Can not seek to encoding data");
  283. return (false);
  284.     }
  286.     if (seekToTable(PCF_BDF_ACCELERATORS)) {
  287. format = getLSB32();
  288. if (!isFormat(PCF_DEFAULT_FORMAT) &&
  289.     !isFormat(PCF_ACCEL_W_INKBOUNDS)) {
  290.     error("Bad BDF accelerator format 0x%lx", format);
  291.     return (false);
  292. }
  293. fseek(file, 8, SEEK_CUR); // skip a bunch of junk
  294. fontAscent = (short) getINT32();
  295. fontDescent = (short) getINT32();
  296. // more stuff...
  297.     } else {
  298. error("Can not seek to BDF accelerator information");
  299. return (false);
  300.     }
  301.     fclose(file), file = NULL;
  302.     filename = NULL;
  303.     return (ready = true);
  304. }
  306. u_long
  307. PCFFont::getLSB32()
  308. {
  309.     u_long c = getc(file);
  310.     c |= getc(file) << 8;
  311.     c |= getc(file) << 16;
  312.     c |= getc(file) << 24;
  313.     return (c);
  314. }
  316. u_long
  317. PCFFont::getINT32()
  318. {
  319.     u_long c;
  320.     if (byteOrder() == MSBFirst) {
  321. c = getc(file) << 24;
  322. c |= getc(file) << 16;
  323. c |= getc(file) << 8;
  324. c |= getc(file);
  325.     } else {
  326. c = getc(file);
  327. c |= getc(file) << 8;
  328. c |= getc(file) << 16;
  329. c |= getc(file) << 24;
  330.     }
  331.     return (c);
  332. }
  334. int
  335. PCFFont::getINT16()
  336. {
  337.     int c;
  338.     if (byteOrder() == MSBFirst) {
  339. c = getc(file) << 8;
  340. c |= getc(file);
  341.     } else {
  342. c = getc(file);
  343. c |= getc(file) << 8;
  344.     }
  345.     return (c);
  346. }
  348. int PCFFont::getINT8() { return getc(file); }
  350. /*
  351.  * PCF supports two formats for metrics, both the regular
  352.  * jumbo size, and 'lite' metrics, which are useful
  353.  * for most fonts which have even vaguely reasonable
  354.  * metrics
  355.  */
  356. void
  357. PCFFont::getMetric(charInfo& metric)
  358. {
  359.     metric.lsb = getINT16();
  360.     metric.rsb = getINT16();
  361.     metric.cw = getINT16();
  362.     metric.ascent = getINT16();
  363.     metric.descent = getINT16();
  364.     (void) getINT16(); // attributes
  365. }
  367. void
  368. PCFFont::getCompressedMetric(charInfo& metric)
  369. {
  370.     metric.lsb = getINT8() - 0x80;
  371.     metric.rsb = getINT8() - 0x80;
  372.     metric.cw = getINT8() - 0x80;
  373.     metric.ascent = getINT8() - 0x80;
  374.     metric.descent = getINT8() - 0x80;
  375. }
  377. /*
  378.  * Position to the begining of the specified table.
  379.  */
  380. bool
  381. PCFFont::seekToTable(u_long type)
  382. {
  383.     for (u_int i = 0; i < tocSize; i++)
  384. if (toc[i].type == type) {
  385.     if (fseek(file, toc[i].offset, SEEK_SET) == -1) {
  386. error("Can not seek; fseek failed");
  387. return (false);
  388.     }
  389.     format = toc[i].format;
  390.     return (true);
  391. }
  392.     error("Can not seek; no such entry in the TOC");
  393.     return (false);
  394. }
  396. /*
  397.  * Read the table-of-contents for the font file.
  398.  */
  399. bool
  400. PCFFont::readTOC()
  401. {
  402.     u_long version = getLSB32();
  403.     if (version != PCF_FILE_VERSION) {
  404. error("Cannot read TOC; bad version number %lu", version);
  405. return (false);
  406.     }
  407.     tocSize = getLSB32();
  408.     toc = new PCFTableRec[tocSize];
  409.     if (!toc) {
  410. error("Cannot read TOC; no space for %lu records", tocSize);
  411. return (false);
  412.     }
  413.     for (u_int i = 0; i < tocSize; i++) {
  414. toc[i].type = getLSB32();
  415. toc[i].format = getLSB32();
  416. toc[i].size = getLSB32();
  417. toc[i].offset = getLSB32();
  418.     }
  419.     return (true);
  420. }
  422. int
  423. PCFFont::repadBitmap(u_char* src, u_char* dst, u_long spad, u_long dpad, int w, int h)
  424. {
  425.     int srcWidthBytes;
  426.     switch (spad) {
  427.     case 1: srcWidthBytes = (w+7)>>3; break;
  428.     case 2: srcWidthBytes = ((w+15)>>4)<<1; break;
  429.     case 4: srcWidthBytes = ((w+31)>>5)<<2; break;
  430.     case 8: srcWidthBytes = ((w+63)>>6)<<3; break;
  431.     default: return 0;
  432.     }
  433.     int dstWidthBytes;
  434.     switch (dpad) {
  435.     case 1: dstWidthBytes = (w+7)>>3; break;
  436.     case 2: dstWidthBytes = ((w+15)>>4)<<1; break;
  437.     case 4: dstWidthBytes = ((w+31)>>5)<<2; break;
  438.     case 8: dstWidthBytes = ((w+63)>>6)<<3; break;
  439.     default: return 0;
  440.     }
  441.     w = srcWidthBytes;
  442.     if (w > dstWidthBytes)
  443. w = dstWidthBytes;
  444.     for (int row = 0; row < h; row++) {
  445. int col;
  446. for (col = 0; col < w; col++)
  447.     *dst++ = *src++;
  448. while (col < dstWidthBytes) {
  449.     *dst++ = '';
  450.     col++;
  451. }
  452. src += srcWidthBytes - w;
  453.     }
  454.     return (dstWidthBytes * h);
  455. }
  457. u_int
  458. PCFFont::charWidth(u_int c) const
  459. {
  460.     if (ready) {
  461. charInfo* ci = (firstCol <= c && c <= lastCol) ?
  462.     encoding[c - firstCol] : cdef;
  463. return (ci ? ci->cw : 0);
  464.     } else
  465. return (0);
  466. }
  468. void
  469. PCFFont::strWidth(const char* text, u_int &sw, u_int& sh) const
  470. {
  471.     sh = fontHeight();
  472.     sw = 0;
  473.     if (ready) {
  474. for (const char* cp = text; *cp; cp++) {
  475.     u_int g = *cp;
  476.     charInfo* ci = (firstCol <= g && g <= lastCol) ?
  477. encoding[g - firstCol] : cdef;
  478.     if (ci)
  479. sw += ci->cw;
  480. }
  481.     }
  482. }
  484. /* merge Left/Right bits from a word in a glyph bitmap */
  485. #define MERGEL(r,g,dx,dm) 
  486.     (r) = ((r) &~ (dm)) | (((g)>>dx) & (dm))
  487. #define MERGER(r,g,dx,dm) 
  488.     (r) = ((r) &~ (dm)) | (((g)<<(dx)) & (dm))
  489. /*
  490.  * Image text into a raster.  The raster origin (0,0) is assumed to
  491.  * be in the upper left.  Text is imaged from top-to-bottom and
  492.  * left-to-right.  The height of the rendered text is returned.
  493.  */
  494. u_int
  495. PCFFont::imageText(const char* text, bool isutf8,
  496.     u_short* raster, u_int w, u_int h,
  497.     u_int lm, u_int rm, u_int tm, u_int bm) const
  498. {
  499.     if (!ready)
  500. return (0);
  501.     u_int rowwords = howmany(w,16);
  502.     u_int y = tm + fontAscent;
  503.     u_int x = lm;
  504.     /*
  505.      * The rasterize assumes words have a big-endian
  506.      * byte order.  For now (rather than fix it) we
  507.      * byte swap the data coming in and going out.
  508.      */
  509.     if (!isBigEndian) // XXX
  510. TIFFSwabArrayOfShort((u_short*) raster, h*rowwords);
  511.     const char* cp = text;
  512.     for (; *cp; cp++) {
  513. u_int g = (u_int)*cp;
  514. if (isutf8 && (g >= 0xC0)) { // first byte in a multibyte character
  515.     /*
  516.      * We probably could use mbstowcs and not perform
  517.      * the UTF-8 decoding ourselves; however, this saves
  518.      * us from needing to use #ifdef __STDC_ISO_10646__
  519.      * and thus able to support UTF-8 on systems where
  520.      * it is not.
  521.      */
  522.     u_short morebytes = 0;
  523.     if ((g & 0x20) == 0) {
  524. morebytes = 1;
  525. g &= 0x1F;
  526.     } else if ((g & 0x10) == 0) {
  527. morebytes = 2;
  528. g &= 0xF;
  529.     } else if ((g & 0x8) == 0) {
  530. morebytes = 3;
  531. g &= 0x7;
  532.     } else if ((g & 0x4) == 0) {
  533. morebytes = 4;
  534. g &= 0x3;
  535.     } else if ((g & 0x2) == 0) {
  536. morebytes = 5;
  537. g &= 0x1;
  538.     }
  539.     for (cp++; morebytes && *cp; morebytes--, cp++) {
  540. g <<= 6;
  541. g += (*cp & 0x3F);
  542.     }
  543.     cp--; // back up one
  544. }
  545. int l = g >> 8;
  546. int c = g & 0xff;
  547. charInfo* ci = (firstRow <= l && l <= lastRow && firstCol <= c && c <= lastCol) ?
  548.     encoding[g - firstCol] : cdef;
  549. if (!ci)
  550.     continue;
  551. if (x + ci->cw > w - rm) { // no space on line, move down
  552.     if (y+fontHeight() >= h-bm)
  553. break; // raster completely full
  554.     y += fontHeight();
  555.     x = lm;
  556. }
  557. /*
  558.  * Blit glyph bitmap into raster.  The work done here is
  559.  * not designed for speed.  We break the work into two cases;
  560.  * where the destination location in the raster is word-aligned
  561.  * and where it's not word-aligned.  Glyph bitmaps are assumed
  562.  * to be word-padded and to have the bits ``left adjusted''
  563.  * within words.  Note that we handle glyphs that are at
  564.  * most 47 bits wide; this should be sufficient for our needs.
  565.  */
  566. u_short cw = ci->rsb - ci->lsb; // bitmap glyph width
  567. u_short cwords = cw>>4; // full words in glyph
  568. if (cwords > 2) // skip too wide glyph
  569.     continue;
  570. int cx = x + ci->lsb; // left edge of glyph
  571. int ch = ci->ascent + ci->descent; // glyph height
  572. u_short* rp = raster + (y-ci->ascent)*rowwords + (cx>>4);
  573. u_short* gp = (u_short*) ci->bits;
  574. u_short dx0 = cx&15; // raster word offset
  575. u_short rowdelta = rowwords - cwords; // raster row adjust factor
  576. u_short cbits = cw&15; // partial glyph word
  577. if (dx0 != 0) { // hard case, raster unaligned
  578.     u_short dm0 = 0xffff>>dx0;
  579.     u_short dx1 = 16-dx0;
  580.     u_short dm1 = ~dm0;
  581.     u_short dm2, dm3;
  582.     if (cbits > dx1) { // spills into 2nd word
  583. dm2 = dm0;
  584. dm3 = ~((1<<dx1)-1);
  585.     } else { // fits entirely into 1st word
  586. dm2 = dm0 &~ ((1<<(dx1-cbits))-1);
  587. dm3 = 0;
  588.     }
  589.     for (short r = 0; r < ch; r++) {
  590. switch (cwords) { // merge complete glyph words
  591. case 2: MERGEL(rp[0], gp[0], dx0, dm0);
  592. MERGER(rp[1], gp[0], dx1, dm1);
  593. rp++, gp++;
  594. case 1: MERGEL(rp[0], gp[0], dx0, dm0);
  595. MERGER(rp[1], gp[0], dx1, dm1);
  596. rp++, gp++;
  597. }
  598. if (cbits) {
  599.     MERGEL(rp[0], gp[0], dx0, dm2);
  600.     MERGER(rp[1], gp[0], dx1, dm3);
  601.     gp++;
  602. }
  603. rp += rowdelta;
  604.     }
  605. } else { // raster word-aligned
  606.     u_short dm = 0xffff<<(16-cbits);
  607.     for (short r = 0; r < ch; r++) {
  608. switch (cwords) {
  609. case 2: *rp++ = *gp++;
  610. case 1: *rp++ = *gp++;
  611. }
  612. if (cbits)
  613.     MERGEL(*rp, *gp++, 0, dm);
  614. rp += rowdelta;
  615.     }
  616. }
  617. x += ci->cw;
  618.     }
  619.     if (!isBigEndian) // XXX
  620. TIFFSwabArrayOfShort((u_short*) raster, h*rowwords);
  621.     return (y+fontDescent+bm);
  622. }
  623. #undef MERGEL
  624. #undef MERGER
  626. #include <ctype.h>
  628. void
  629. PCFFont::print(FILE* fd) const
  630. {
  631.     if (ready) {
  632. fprintf(fd, "Font Ascent: %d Descent: %dn", fontAscent, fontDescent);
  633. fprintf(fd, "FirstCol: %u LastCol: %un", firstCol, lastCol);
  634. fprintf(fd, "%lu glyphs:n", numGlyphs);
  635. for (u_int c = firstCol; c <= lastCol; c++) {
  636.     charInfo* ci = encoding[c - firstCol];
  637.     if (!ci)
  638. continue;
  639.     if (isprint(c))
  640. fprintf(fd,
  641.     "'%c': lsb %2d rsb %2d cw %2d ascent %2d descent %dn",
  642.     c, ci->lsb, ci->rsb, ci->cw, ci->ascent, ci->descent);
  643.     else
  644. fprintf(fd,
  645.     "%3d: lsb %2d rsb %2d cw %2d ascent %2d descent %dn",
  646.     c, ci->lsb, ci->rsb, ci->cw, ci->ascent, ci->descent);
  647. }
  648.     }
  649. }
  651. #include "Str.h"
  653. extern void vlogError(const char* fmt, va_list ap);
  655. void
  656. PCFFont::error(const char* fmt0 ...)
  657. {
  658.     va_list ap;
  659.     va_start(ap, fmt0);
  660.     fxStr fmt = fxStr::format("PCFFont: %s: %s",
  661. filename ? filename : "<unknown file>", fmt0);
  662.     vlogError(fmt, ap);
  663.     va_end(ap);
  664. }
  666. /*
  667.  * $XConsortium: pcfread.c,v 1.10 92/05/12 18:07:47 gildea Exp $
  668.  *
  669.  * Copyright 1990 Massachusetts Institute of Technology
  670.  *
  671.  * Permission to use, copy, modify, distribute, and sell this software and its
  672.  * documentation for any purpose is hereby granted without fee, provided that
  673.  * the above copyright notice appear in all copies and that both that
  674.  * copyright notice and this permission notice appear in supporting
  675.  * documentation, and that the name of M.I.T. not be used in advertising or
  676.  * publicity pertaining to distribution of the software without specific,
  677.  * written prior permission.  M.I.T. makes no representations about the
  678.  * suitability of this software for any purpose.  It is provided "as is"
  679.  * without express or implied warranty.
  680.  *
  681.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  682.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  683.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  684.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  685.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  686.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  687.  *
  688.  * Author:  Keith Packard, MIT X Consortium
  689.  */