source/libs/poppler/poppler-0.36.0/poppler/GfxFont.h

   1 //========================================================================
   2 //
   3 // GfxFont.h
   4 //
   5 // Copyright 1996-2003 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 //========================================================================
  10 //
  11 // Modified under the Poppler project - http://poppler.freedesktop.org
  12 //
  13 // All changes made under the Poppler project to this file are licensed
  14 // under GPL version 2 or later
  15 //
  16 // Copyright (C) 2005, 2008, 2015 Albert Astals Cid <aacid@kde.org>
  17 // Copyright (C) 2006 Takashi Iwai <tiwai@suse.de>
  18 // Copyright (C) 2006 Kristian Høgsberg <krh@redhat.com>
  19 // Copyright (C) 2007 Julien Rebetez <julienr@svn.gnome.org>
  20 // Copyright (C) 2007 Jeff Muizelaar <jeff@infidigm.net>
  21 // Copyright (C) 2007 Koji Otani <sho@bbr.jp>
  22 // Copyright (C) 2011 Axel Strübing <axel.struebing@freenet.de>
  23 // Copyright (C) 2011, 2012, 2014 Adrian Johnson <ajohnson@redneon.com>
  24 // Copyright (C) 2015 Jason Crain <jason@aquaticape.us>
  25 //
  26 // To see a description of the changes please see the Changelog file that
  27 // came with your tarball or type make ChangeLog if you are building from git
  28 //
  29 //========================================================================
  30
  31 #ifndef GFXFONT_H
  32 #define GFXFONT_H
  33
  34 #ifdef USE_GCC_PRAGMAS
  35 #pragma interface
  36 #endif
  37
  38 #include "goo/gtypes.h"
  39 #include "goo/GooString.h"
  40 #include "Object.h"
  41 #include "CharTypes.h"
  42
  43 class Dict;
  44 class CMap;
  45 class CharCodeToUnicode;
  46 class FoFiTrueType;
  47 class PSOutputDev;
  48 struct GfxFontCIDWidths;
  49 struct Base14FontMapEntry;
  50
  51 //------------------------------------------------------------------------
  52 // GfxFontType
  53 //------------------------------------------------------------------------
  54
  55 enum GfxFontType {
  56   //----- Gfx8BitFont
  57   fontUnknownType,
  58   fontType1,
  59   fontType1C,
  60   fontType1COT,
  61   fontType3,
  62   fontTrueType,
  63   fontTrueTypeOT,
  64   //----- GfxCIDFont
  65   fontCIDType0,
  66   fontCIDType0C,
  67   fontCIDType0COT,
  68   fontCIDType2,
  69   fontCIDType2OT
  70 };
  71
  72 //------------------------------------------------------------------------
  73 // GfxFontCIDWidths
  74 //------------------------------------------------------------------------
  75
  76 struct GfxFontCIDWidthExcep {
  77   CID first;                    // this record applies to
  78   CID last;                     //   CIDs <first>..<last>
  79   double width;                 // char width
  80 };
  81
  82 struct GfxFontCIDWidthExcepV {
  83   CID first;                    // this record applies to
  84   CID last;                     //   CIDs <first>..<last>
  85   double height;                // char height
  86   double vx, vy;                // origin position
  87 };
  88
  89 struct GfxFontCIDWidths {
  90   double defWidth;              // default char width
  91   double defHeight;             // default char height
  92   double defVY;                 // default origin position
  93   GfxFontCIDWidthExcep *exceps; // exceptions
  94   int nExceps;                  // number of valid entries in exceps
  95   GfxFontCIDWidthExcepV *       // exceptions for vertical font
  96     excepsV;
  97   int nExcepsV;                 // number of valid entries in excepsV
  98 };
  99
 100 //------------------------------------------------------------------------
 101 // GfxFontLoc
 102 //------------------------------------------------------------------------
 103
 104 enum GfxFontLocType {
 105   gfxFontLocEmbedded,           // font embedded in PDF file
 106   gfxFontLocExternal,           // external font file
 107   gfxFontLocResident            // font resident in PS printer
 108 };
 109
 110 class GfxFontLoc {
 111 public:
 112
 113   GfxFontLoc();
 114   ~GfxFontLoc();
 115
 116   GfxFontLocType locType;
 117   GfxFontType fontType;
 118   Ref embFontID;                // embedded stream obj ID
 119                                 //   (if locType == gfxFontLocEmbedded)
 120   GooString *path;              // font file path
 121                                 //   (if locType == gfxFontLocExternal)
 122                                 // PS font name
 123                                 //   (if locType == gfxFontLocResident)
 124   int fontNum;                  // for TrueType collections
 125                                 //   (if locType == gfxFontLocExternal)
 126   GooString *encoding;          // PS font encoding, only for 16-bit fonts
 127                                 //   (if locType == gfxFontLocResident)
 128   int wMode;                    // writing mode, only for 16-bit fonts
 129                                 //   (if locType == gfxFontLocResident)
 130   int substIdx;                 // substitute font index
 131                                 //   (if locType == gfxFontLocExternal,
 132                                 //   and a Base-14 substitution was made)
 133 };
 134
 135 //------------------------------------------------------------------------
 136 // GfxFont
 137 //------------------------------------------------------------------------
 138
 139 #define fontFixedWidth (1 << 0)
 140 #define fontSerif      (1 << 1)
 141 #define fontSymbolic   (1 << 2)
 142 #define fontItalic     (1 << 6)
 143 #define fontBold       (1 << 18)
 144
 145 class GfxFont {
 146 public:
 147
 148   enum Stretch {
 149         StretchNotDefined,
 150         UltraCondensed,
 151         ExtraCondensed,
 152         Condensed,
 153         SemiCondensed,
 154         Normal,
 155         SemiExpanded,
 156         Expanded,
 157         ExtraExpanded,
 158         UltraExpanded };
 159
 160   enum Weight {
 161         WeightNotDefined,
 162         W100,
 163         W200,
 164         W300,
 165         W400, // Normal
 166         W500,
 167         W600,
 168         W700, // Bold
 169         W800,
 170         W900 };
 171
 172   // Build a GfxFont object.
 173   static GfxFont *makeFont(XRef *xref, const char *tagA, Ref idA, Dict *fontDict);
 174
 175   GfxFont(const char *tagA, Ref idA, GooString *nameA,
 176           GfxFontType typeA, Ref embFontIDA);
 177
 178   GBool isOk() { return ok; }
 179
 180   void incRefCnt();
 181   void decRefCnt();
 182
 183   // Get font tag.
 184   GooString *getTag() { return tag; }
 185
 186   // Get font dictionary ID.
 187   Ref *getID() { return &id; }
 188
 189   // Does this font match the tag?
 190   GBool matches(char *tagA) { return !tag->cmp(tagA); }
 191
 192   // Get font family name.
 193   GooString *getFamily() { return family; }
 194
 195   // Get font stretch.
 196   Stretch getStretch() { return stretch; }
 197
 198   // Get font weight.
 199   Weight getWeight() { return weight; }
 200
 201   // Get the original font name (ignornig any munging that might have
 202   // been done to map to a canonical Base-14 font name).
 203   GooString *getName() { return name; }
 204
 205   // Get font type.
 206   GfxFontType getType() { return type; }
 207   virtual GBool isCIDFont() { return gFalse; }
 208
 209   // Get embedded font ID, i.e., a ref for the font file stream.
 210   // Returns false if there is no embedded font.
 211   GBool getEmbeddedFontID(Ref *embID)
 212     { *embID = embFontID; return embFontID.num >= 0; }
 213
 214   // Get the PostScript font name for the embedded font.  Returns
 215   // NULL if there is no embedded font.
 216   GooString *getEmbeddedFontName() { return embFontName; }
 217
 218   // Get font descriptor flags.
 219   int getFlags() { return flags; }
 220   GBool isFixedWidth() { return flags & fontFixedWidth; }
 221   GBool isSerif() { return flags & fontSerif; }
 222   GBool isSymbolic() { return flags & fontSymbolic; }
 223   GBool isItalic() { return flags & fontItalic; }
 224   GBool isBold() { return flags & fontBold; }
 225
 226   // Return the Unicode map.
 227   virtual CharCodeToUnicode *getToUnicode() = 0;
 228
 229   // Return the font matrix.
 230   double *getFontMatrix() { return fontMat; }
 231
 232   // Return the font bounding box.
 233   double *getFontBBox() { return fontBBox; }
 234
 235   // Return the ascent and descent values.
 236   double getAscent() { return ascent; }
 237   double getDescent() { return descent; }
 238
 239   // Return the writing mode (0=horizontal, 1=vertical).
 240   virtual int getWMode() { return 0; }
 241
 242   // Locate the font file for this font.  If <ps> is not null, includes PS
 243   // printer-resident fonts.  Returns NULL on failure.
 244   GfxFontLoc *locateFont(XRef *xref, PSOutputDev *ps);
 245
 246   // Locate a Base-14 font file for a specified font name.
 247   static GfxFontLoc *locateBase14Font(GooString *base14Name);
 248
 249   // Read an external or embedded font file into a buffer.
 250   char *readEmbFontFile(XRef *xref, int *len);
 251
 252   // Get the next char from a string <s> of <len> bytes, returning the
 253   // char <code>, its Unicode mapping <u>, its displacement vector
 254   // (<dx>, <dy>), and its origin offset vector (<ox>, <oy>).  <uSize>
 255   // is the number of entries available in <u>, and <uLen> is set to
 256   // the number actually used.  Returns the number of bytes used by
 257   // the char code.
 258   virtual int getNextChar(char *s, int len, CharCode *code,
 259                           Unicode **u, int *uLen,
 260                           double *dx, double *dy, double *ox, double *oy) = 0;
 261
 262   // Does this font have a toUnicode map?
 263   GBool hasToUnicodeCMap() { return hasToUnicode; }
 264
 265   // Return the name of the encoding
 266   GooString *getEncodingName() { return encodingName; }
 267
 268   // Return AGLFN names of ligatures in the Standard and Expert encodings
 269   // for use with fonts that are not compatible with the Standard 14 fonts.
 270   // http://sourceforge.net/adobe/aglfn/wiki/AGL%20Specification/
 271   static const char *getAlternateName(const char *name);
 272
 273 protected:
 274
 275   virtual ~GfxFont();
 276
 277   static GfxFontType getFontType(XRef *xref, Dict *fontDict, Ref *embID);
 278   void readFontDescriptor(XRef *xref, Dict *fontDict);
 279   CharCodeToUnicode *readToUnicodeCMap(Dict *fontDict, int nBits,
 280                                        CharCodeToUnicode *ctu);
 281   static GfxFontLoc *getExternalFont(GooString *path, GBool cid);
 282
 283   GooString *tag;                       // PDF font tag
 284   Ref id;                       // reference (used as unique ID)
 285   GooString *name;              // font name
 286   GooString *family;            // font family
 287   Stretch stretch;                      // font stretch
 288   Weight weight;                        // font weight
 289   GfxFontType type;             // type of font
 290   int flags;                    // font descriptor flags
 291   GooString *embFontName;               // name of embedded font
 292   Ref embFontID;                // ref to embedded font file stream
 293   double fontMat[6];            // font matrix (Type 3 only)
 294   double fontBBox[4];           // font bounding box (Type 3 only)
 295   double missingWidth;          // "default" width
 296   double ascent;                // max height above baseline
 297   double descent;               // max depth below baseline
 298   int refCnt;
 299   GBool ok;
 300   GBool hasToUnicode;
 301   GooString *encodingName;
 302 };
 303
 304 //------------------------------------------------------------------------
 305 // Gfx8BitFont
 306 //------------------------------------------------------------------------
 307
 308 class Gfx8BitFont: public GfxFont {
 309 public:
 310
 311   Gfx8BitFont(XRef *xref, const char *tagA, Ref idA, GooString *nameA,
 312               GfxFontType typeA, Ref embFontIDA, Dict *fontDict);
 313
 314   virtual int getNextChar(char *s, int len, CharCode *code,
 315                           Unicode **u, int *uLen,
 316                           double *dx, double *dy, double *ox, double *oy);
 317
 318   // Return the encoding.
 319   char **getEncoding() { return enc; }
 320
 321   // Return the Unicode map.
 322   CharCodeToUnicode *getToUnicode();
 323
 324   // Return the character name associated with <code>.
 325   char *getCharName(int code) { return enc[code]; }
 326
 327   // Returns true if the PDF font specified an encoding.
 328   GBool getHasEncoding() { return hasEncoding; }
 329
 330   // Returns true if the PDF font specified MacRomanEncoding.
 331   GBool getUsesMacRomanEnc() { return usesMacRomanEnc; }
 332
 333   // Get width of a character.
 334   double getWidth(Guchar c) { return widths[c]; }
 335
 336   // Return a char code-to-GID mapping for the provided font file.
 337   // (This is only useful for TrueType fonts.)
 338   int *getCodeToGIDMap(FoFiTrueType *ff);
 339
 340   // Return the Type 3 CharProc dictionary, or NULL if none.
 341   Dict *getCharProcs();
 342
 343   // Return the Type 3 CharProc for the character associated with <code>.
 344   Object *getCharProc(int code, Object *proc);
 345
 346   // Return the Type 3 Resources dictionary, or NULL if none.
 347   Dict *getResources();
 348
 349 private:
 350   virtual ~Gfx8BitFont();
 351
 352   const Base14FontMapEntry *base14;     // for Base-14 fonts only; NULL otherwise
 353   char *enc[256];               // char code --> char name
 354   char encFree[256];            // boolean for each char name: if set,
 355                                 //   the string is malloc'ed
 356   CharCodeToUnicode *ctu;       // char code --> Unicode
 357   GBool hasEncoding;
 358   GBool usesMacRomanEnc;
 359   double widths[256];           // character widths
 360   Object charProcs;             // Type 3 CharProcs dictionary
 361   Object resources;             // Type 3 Resources dictionary
 362
 363   friend class GfxFont;
 364 };
 365
 366 //------------------------------------------------------------------------
 367 // GfxCIDFont
 368 //------------------------------------------------------------------------
 369
 370 class GfxCIDFont: public GfxFont {
 371 public:
 372
 373   GfxCIDFont(XRef *xref, const char *tagA, Ref idA, GooString *nameA,
 374              GfxFontType typeA, Ref embFontIDA, Dict *fontDict);
 375
 376   virtual GBool isCIDFont() { return gTrue; }
 377
 378   virtual int getNextChar(char *s, int len, CharCode *code,
 379                           Unicode **u, int *uLen,
 380                           double *dx, double *dy, double *ox, double *oy);
 381
 382   // Return the writing mode (0=horizontal, 1=vertical).
 383   virtual int getWMode();
 384
 385   // Return the Unicode map.
 386   CharCodeToUnicode *getToUnicode();
 387
 388   // Get the collection name (<registry>-<ordering>).
 389   GooString *getCollection();
 390
 391   // Return the CID-to-GID mapping table.  These should only be called
 392   // if type is fontCIDType2.
 393   int *getCIDToGID() { return cidToGID; }
 394   int getCIDToGIDLen() { return cidToGIDLen; }
 395
 396   int *getCodeToGIDMap(FoFiTrueType *ff, int *length);
 397
 398   double getWidth(char* s, int len);
 399
 400 private:
 401   virtual ~GfxCIDFont();
 402
 403   int mapCodeToGID(FoFiTrueType *ff, int cmapi,
 404     Unicode unicode, GBool wmode);
 405   double getWidth(CID cid);     // Get width of a character.
 406
 407   GooString *collection;                // collection name
 408   CMap *cMap;                   // char code --> CID
 409   CharCodeToUnicode *ctu;       // CID --> Unicode
 410   GBool ctuUsesCharCode;        // true: ctu maps char code to Unicode;
 411                                 //   false: ctu maps CID to Unicode
 412   GfxFontCIDWidths widths;      // character widths
 413   int *cidToGID;                // CID --> GID mapping (for embedded
 414                                 //   TrueType fonts)
 415   int cidToGIDLen;
 416 };
 417
 418 //------------------------------------------------------------------------
 419 // GfxFontDict
 420 //------------------------------------------------------------------------
 421
 422 class GfxFontDict {
 423 public:
 424
 425   // Build the font dictionary, given the PDF font dictionary.
 426   GfxFontDict(XRef *xref, Ref *fontDictRef, Dict *fontDict);
 427
 428   // Destructor.
 429   ~GfxFontDict();
 430
 431   // Get the specified font.
 432   GfxFont *lookup(char *tag);
 433
 434   // Iterative access.
 435   int getNumFonts() { return numFonts; }
 436   GfxFont *getFont(int i) { return fonts[i]; }
 437
 438 private:
 439
 440   GfxFont **fonts;              // list of fonts
 441   int numFonts;                 // number of fonts
 442 };
 443
 444 #endif