pdftops/GfxFont.h

   1 //========================================================================
   2 //
   3 // GfxFont.h
   4 //
   5 // Copyright 1996-2003 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 #ifndef GFXFONT_H
  10 #define GFXFONT_H
  11
  12 #include <config.h>
  13
  14 #ifdef USE_GCC_PRAGMAS
  15 #pragma interface
  16 #endif
  17
  18 #include "gtypes.h"
  19 #include "GString.h"
  20 #include "Object.h"
  21 #include "CharTypes.h"
  22
  23 class Dict;
  24 class CMap;
  25 class CharCodeToUnicode;
  26 class FoFiTrueType;
  27 struct GfxFontCIDWidths;
  28
  29 //------------------------------------------------------------------------
  30 // GfxFontType
  31 //------------------------------------------------------------------------
  32
  33 enum GfxFontType {
  34   //----- Gfx8BitFont
  35   fontUnknownType,
  36   fontType1,
  37   fontType1C,
  38   fontType3,
  39   fontTrueType,
  40   //----- GfxCIDFont
  41   fontCIDType0,
  42   fontCIDType0C,
  43   fontCIDType2
  44 };
  45
  46 //------------------------------------------------------------------------
  47 // GfxFontCIDWidths
  48 //------------------------------------------------------------------------
  49
  50 struct GfxFontCIDWidthExcep {
  51   CID first;                    // this record applies to
  52   CID last;                     //   CIDs <first>..<last>
  53   double width;                 // char width
  54 };
  55
  56 struct GfxFontCIDWidthExcepV {
  57   CID first;                    // this record applies to
  58   CID last;                     //   CIDs <first>..<last>
  59   double height;                // char height
  60   double vx, vy;                // origin position
  61 };
  62
  63 struct GfxFontCIDWidths {
  64   double defWidth;              // default char width
  65   double defHeight;             // default char height
  66   double defVY;                 // default origin position
  67   GfxFontCIDWidthExcep *exceps; // exceptions
  68   int nExceps;                  // number of valid entries in exceps
  69   GfxFontCIDWidthExcepV *       // exceptions for vertical font
  70     excepsV;
  71   int nExcepsV;                 // number of valid entries in excepsV
  72 };
  73
  74 //------------------------------------------------------------------------
  75 // GfxFont
  76 //------------------------------------------------------------------------
  77
  78 #define fontFixedWidth (1 << 0)
  79 #define fontSerif      (1 << 1)
  80 #define fontSymbolic   (1 << 2)
  81 #define fontItalic     (1 << 6)
  82 #define fontBold       (1 << 18)
  83
  84 class GfxFont {
  85 public:
  86
  87   // Build a GfxFont object.
  88   static GfxFont *makeFont(XRef *xref, char *tagA, Ref idA, Dict *fontDict);
  89
  90   GfxFont(char *tagA, Ref idA, GString *nameA);
  91
  92   virtual ~GfxFont();
  93
  94   GBool isOk() { return ok; }
  95
  96   // Get font tag.
  97   GString *getTag() { return tag; }
  98
  99   // Get font dictionary ID.
 100   Ref *getID() { return &id; }
 101
 102   // Does this font match the tag?
 103   GBool matches(char *tagA) { return !tag->cmp(tagA); }
 104
 105   // Get base font name.
 106   GString *getName() { return name; }
 107
 108   // Get the original font name (ignornig any munging that might have
 109   // been done to map to a canonical Base-14 font name).
 110   GString *getOrigName() { return origName; }
 111
 112   // Get font type.
 113   GfxFontType getType() { return type; }
 114   virtual GBool isCIDFont() { return gFalse; }
 115
 116   // Get embedded font ID, i.e., a ref for the font file stream.
 117   // Returns false if there is no embedded font.
 118   GBool getEmbeddedFontID(Ref *embID)
 119     { *embID = embFontID; return embFontID.num >= 0; }
 120
 121   // Get the PostScript font name for the embedded font.  Returns
 122   // NULL if there is no embedded font.
 123   GString *getEmbeddedFontName() { return embFontName; }
 124
 125   // Get the name of the external font file.  Returns NULL if there
 126   // is no external font file.
 127   GString *getExtFontFile() { return extFontFile; }
 128
 129   // Get font descriptor flags.
 130   GBool isFixedWidth() { return flags & fontFixedWidth; }
 131   GBool isSerif() { return flags & fontSerif; }
 132   GBool isSymbolic() { return flags & fontSymbolic; }
 133   GBool isItalic() { return flags & fontItalic; }
 134   GBool isBold() { return flags & fontBold; }
 135
 136   // Return the font matrix.
 137   double *getFontMatrix() { return fontMat; }
 138
 139   // Return the font bounding box.
 140   double *getFontBBox() { return fontBBox; }
 141
 142   // Return the ascent and descent values.
 143   double getAscent() { return ascent; }
 144   double getDescent() { return descent; }
 145
 146   // Return the writing mode (0=horizontal, 1=vertical).
 147   virtual int getWMode() { return 0; }
 148
 149   // Read an external or embedded font file into a buffer.
 150   char *readExtFontFile(int *len);
 151   char *readEmbFontFile(XRef *xref, int *len);
 152
 153   // Get the next char from a string <s> of <len> bytes, returning the
 154   // char <code>, its Unicode mapping <u>, its displacement vector
 155   // (<dx>, <dy>), and its origin offset vector (<ox>, <oy>).  <uSize>
 156   // is the number of entries available in <u>, and <uLen> is set to
 157   // the number actually used.  Returns the number of bytes used by
 158   // the char code.
 159   virtual int getNextChar(char *s, int len, CharCode *code,
 160                           Unicode *u, int uSize, int *uLen,
 161                           double *dx, double *dy, double *ox, double *oy) = 0;
 162
 163 protected:
 164
 165   void readFontDescriptor(XRef *xref, Dict *fontDict);
 166   CharCodeToUnicode *readToUnicodeCMap(Dict *fontDict, int nBits,
 167                                        CharCodeToUnicode *ctu);
 168   void findExtFontFile();
 169
 170   GString *tag;                 // PDF font tag
 171   Ref id;                       // reference (used as unique ID)
 172   GString *name;                // font name
 173   GString *origName;            // original font name
 174   GfxFontType type;             // type of font
 175   int flags;                    // font descriptor flags
 176   GString *embFontName;         // name of embedded font
 177   Ref embFontID;                // ref to embedded font file stream
 178   GString *extFontFile;         // external font file name
 179   double fontMat[6];            // font matrix (Type 3 only)
 180   double fontBBox[4];           // font bounding box (Type 3 only)
 181   double missingWidth;          // "default" width
 182   double ascent;                // max height above baseline
 183   double descent;               // max depth below baseline
 184   GBool ok;
 185 };
 186
 187 //------------------------------------------------------------------------
 188 // Gfx8BitFont
 189 //------------------------------------------------------------------------
 190
 191 class Gfx8BitFont: public GfxFont {
 192 public:
 193
 194   Gfx8BitFont(XRef *xref, char *tagA, Ref idA, GString *nameA,
 195               GfxFontType typeA, Dict *fontDict);
 196
 197   virtual ~Gfx8BitFont();
 198
 199   virtual int getNextChar(char *s, int len, CharCode *code,
 200                           Unicode *u, int uSize, int *uLen,
 201                           double *dx, double *dy, double *ox, double *oy);
 202
 203   // Return the encoding.
 204   char **getEncoding() { return enc; }
 205
 206   // Return the Unicode map.
 207   CharCodeToUnicode *getToUnicode();
 208
 209   // Return the character name associated with <code>.
 210   char *getCharName(int code) { return enc[code]; }
 211
 212   // Returns true if the PDF font specified an encoding.
 213   GBool getHasEncoding() { return hasEncoding; }
 214
 215   // Returns true if the PDF font specified MacRomanEncoding.
 216   GBool getUsesMacRomanEnc() { return usesMacRomanEnc; }
 217
 218   // Get width of a character.
 219   double getWidth(Guchar c) { return widths[c]; }
 220
 221   // Return a char code-to-GID mapping for the provided font file.
 222   // (This is only useful for TrueType fonts.)
 223   Gushort *getCodeToGIDMap(FoFiTrueType *ff);
 224
 225   // Return the Type 3 CharProc dictionary, or NULL if none.
 226   Dict *getCharProcs();
 227
 228   // Return the Type 3 CharProc for the character associated with <code>.
 229   Object *getCharProc(int code, Object *proc);
 230
 231   // Return the Type 3 Resources dictionary, or NULL if none.
 232   Dict *getResources();
 233
 234 private:
 235
 236   char *enc[256];               // char code --> char name
 237   char encFree[256];            // boolean for each char name: if set,
 238                                 //   the string is malloc'ed
 239   CharCodeToUnicode *ctu;       // char code --> Unicode
 240   GBool hasEncoding;
 241   GBool usesMacRomanEnc;
 242   double widths[256];           // character widths
 243   Object charProcs;             // Type 3 CharProcs dictionary
 244   Object resources;             // Type 3 Resources dictionary
 245 };
 246
 247 //------------------------------------------------------------------------
 248 // GfxCIDFont
 249 //------------------------------------------------------------------------
 250
 251 class GfxCIDFont: public GfxFont {
 252 public:
 253
 254   GfxCIDFont(XRef *xref, char *tagA, Ref idA, GString *nameA,
 255              Dict *fontDict);
 256
 257   virtual ~GfxCIDFont();
 258
 259   virtual GBool isCIDFont() { return gTrue; }
 260
 261   virtual int getNextChar(char *s, int len, CharCode *code,
 262                           Unicode *u, int uSize, int *uLen,
 263                           double *dx, double *dy, double *ox, double *oy);
 264
 265   // Return the writing mode (0=horizontal, 1=vertical).
 266   virtual int getWMode();
 267
 268   // Return the Unicode map.
 269   CharCodeToUnicode *getToUnicode();
 270
 271   // Get the collection name (<registry>-<ordering>).
 272   GString *getCollection();
 273
 274   // Return the CID-to-GID mapping table.  These should only be called
 275   // if type is fontCIDType2.
 276   Gushort *getCIDToGID() { return cidToGID; }
 277   int getCIDToGIDLen() { return cidToGIDLen; }
 278
 279 private:
 280
 281   CMap *cMap;                   // char code --> CID
 282   CharCodeToUnicode *ctu;       // CID --> Unicode
 283   GfxFontCIDWidths widths;      // character widths
 284   Gushort *cidToGID;            // CID --> GID mapping (for embedded
 285                                 //   TrueType fonts)
 286   int cidToGIDLen;
 287 };
 288
 289 //------------------------------------------------------------------------
 290 // GfxFontDict
 291 //------------------------------------------------------------------------
 292
 293 class GfxFontDict {
 294 public:
 295
 296   // Build the font dictionary, given the PDF font dictionary.
 297   GfxFontDict(XRef *xref, Ref *fontDictRef, Dict *fontDict);
 298
 299   // Destructor.
 300   ~GfxFontDict();
 301
 302   // Get the specified font.
 303   GfxFont *lookup(char *tag);
 304
 305   // Iterative access.
 306   int getNumFonts() { return numFonts; }
 307   GfxFont *getFont(int i) { return fonts[i]; }
 308
 309 private:
 310
 311   GfxFont **fonts;              // list of fonts
 312   int numFonts;                 // number of fonts
 313 };
 314
 315 #endif