pdf2swf/xpdf/GfxFont.h

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