pdf/xpdf/GfxFont.h

   1 //========================================================================
   2 //
   3 // GfxFont.h
   4 //
   5 // Copyright 1996 Derek B. Noonburg
   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
  20 class Dict;
  21
  22 //------------------------------------------------------------------------
  23 // GfxFontEncoding
  24 //------------------------------------------------------------------------
  25
  26 #define gfxFontEncHashSize 419
  27
  28 class GfxFontEncoding {
  29 public:
  30
  31   // Construct an empty encoding.
  32   GfxFontEncoding();
  33
  34   // Construct an encoding from an array of char names.
  35   GfxFontEncoding(char **encoding1, int encSize);
  36
  37   // Destructor.
  38   ~GfxFontEncoding();
  39
  40   // Add a char to the encoding.
  41   void addChar(int code, char *name);
  42
  43   // Return the character name associated with <code>.
  44   char *getCharName(int code) { return encoding[code]; }
  45
  46   // Return the code associated with <name>.
  47   int getCharCode(char *name);
  48
  49 private:
  50
  51   int hash(char *name);
  52   void addChar1(int code, char *name);
  53
  54   char **encoding;              // code --> name mapping
  55   GBool freeEnc;                // should we free the encoding array?
  56   short                         // name --> code hash table
  57     hashTab[gfxFontEncHashSize];
  58 };
  59
  60 //------------------------------------------------------------------------
  61 // GfxFontCharSet16
  62 //------------------------------------------------------------------------
  63
  64 enum GfxFontCharSet16 {
  65   font16AdobeJapan12                    // Adobe-Japan1-2
  66 };
  67
  68 //------------------------------------------------------------------------
  69 // GfxFontEncoding16
  70 //------------------------------------------------------------------------
  71
  72 struct GfxFontEncoding16 {
  73   Guchar codeLen[256];          // length of codes, in bytes, indexed by
  74                                 //   first byte of code
  75   Gushort map1[256];            // one-byte code mapping:
  76                                 //   map1[code] --> 16-bit char selector
  77   Gushort *map2;                // two-byte code mapping
  78                                 //   map2[2*i]   --> first code in range
  79                                 //   map2[2*i+1] --> 16-bit char selector
  80                                 //                   for map2[2*i]
  81   int map2Len;                  // length of map2 array (divided by 2)
  82 };
  83
  84 //------------------------------------------------------------------------
  85 // GfxFontWidths16
  86 //------------------------------------------------------------------------
  87
  88 struct GfxFontWidthExcep {
  89   int first;                    // chars <first>..<last> have
  90   int last;                     //   width <width>
  91   double width;
  92 };
  93
  94 struct GfxFontWidths16 {
  95   double defWidth;              // default char width
  96   GfxFontWidthExcep *exceps;    // exceptions
  97   int numExceps;                // number of valid entries in exceps
  98 };
  99
 100 //------------------------------------------------------------------------
 101 // GfxFont
 102 //------------------------------------------------------------------------
 103
 104 #define fontFixedWidth (1 << 0)
 105 #define fontSerif      (1 << 1)
 106 #define fontSymbolic   (1 << 2)
 107 #define fontItalic     (1 << 6)
 108 #define fontBold       (1 << 18)
 109
 110 enum GfxFontType {
 111   fontUnknownType,
 112   fontType1,
 113   fontType3,
 114   fontTrueType,
 115   fontType0
 116 };
 117
 118 class GfxFont {
 119 public:
 120
 121   // Constructor.
 122   GfxFont(char *tag1, Ref id1, Dict *fontDict);
 123
 124   // Destructor.
 125   ~GfxFont();
 126
 127   // Get font tag.
 128   GString *getTag() { return tag; }
 129
 130   // Get font dictionary ID.
 131   Ref getID() { return id; }
 132
 133   // Does this font match the tag?
 134   GBool matches(char *tag1) { return !tag->cmp(tag1); }
 135
 136   // Get base font name.
 137   GString *getName() { return name; }
 138
 139   // Get font type.
 140   GfxFontType getType() { return type; }
 141
 142   // Does this font use 16-bit characters?
 143   GBool is16Bit() { return is16; }
 144
 145   // Get embedded font ID, i.e., a ref for the font file stream.
 146   // Returns false if there is no embedded font.
 147   GBool getEmbeddedFontID(Ref *embID)
 148     { *embID = embFontID; return embFontID.num >= 0; }
 149
 150   // Get the PostScript font name for the embedded font.  Returns
 151   // NULL if there is no embedded font.
 152   char *getEmbeddedFontName()
 153     { return embFontName ? embFontName->getCString() : (char *)NULL; }
 154
 155   // Get the name of the external font file.  Returns NULL if there
 156   // is no external font file.
 157   char *getExtFontFile()
 158     { return extFontFile ? extFontFile->getCString() : (char *)NULL; }
 159
 160   // Get font descriptor flags.
 161   GBool isFixedWidth() { return flags & fontFixedWidth; }
 162   GBool isSerif() { return flags & fontSerif; }
 163   GBool isSymbolic() { return flags & fontSymbolic; }
 164   GBool isItalic() { return flags & fontItalic; }
 165   GBool isBold() { return flags & fontBold; }
 166
 167   // Get width of a character or string.
 168   double getWidth(Guchar c) { return widths[c]; }
 169   double getWidth(GString *s);
 170   double getWidth16(int c);
 171   double getWidth16(GString *s);
 172
 173   // Return the character name associated with <code>.
 174   char *getCharName(int code) { return encoding->getCharName(code); }
 175
 176   // Return the code associated with <name>.
 177   int getCharCode(char *charName) { return encoding->getCharCode(charName); }
 178
 179   // Return the 16-bit character set and encoding.
 180   GfxFontCharSet16 getCharSet16() { return enc16.charSet; }
 181   GfxFontEncoding16 *getEncoding16() { return enc16.enc; }
 182
 183   // Return the font matrix.
 184   double *getFontMatrix() { return fontMat; }
 185
 186 private:
 187
 188   void makeEncoding(Dict *fontDict, GfxFontEncoding *builtinEncoding);
 189   GfxFontEncoding *makeEncoding1(Object obj, Dict *fontDesc,
 190                                  GfxFontEncoding *builtinEncoding);
 191   void getType1Encoding(Stream *str);
 192   void makeWidths(Dict *fontDict, GfxFontEncoding *builtinEncoding,
 193                   Gushort *builtinWidths);
 194   void getType0EncAndWidths(Dict *fontDict);
 195
 196   GString *tag;                 // PDF font tag
 197   Ref id;                       // reference (used as unique ID)
 198   GString *name;                // font name
 199   int flags;                    // font descriptor flags
 200   GfxFontType type;             // type of font
 201   GBool is16;                   // set if font uses 16-bit chars
 202   GString *embFontName;         // name of embedded font
 203   Ref embFontID;                // ref to embedded font file stream
 204   GString *extFontFile;         // external font file name
 205   double fontMat[6];            // font matrix
 206   union {
 207     GfxFontEncoding *encoding;  // 8-bit font encoding
 208     struct {
 209       GfxFontCharSet16 charSet; // 16-bit character set
 210       GfxFontEncoding16 *enc;   // 16-bit encoding (CMap)
 211     } enc16;
 212   };
 213   union {
 214     double widths[256];         // width of each char for 8-bit font
 215     GfxFontWidths16 widths16;   // char widths for 16-bit font
 216   };
 217 };
 218
 219 //------------------------------------------------------------------------
 220 // GfxFontDict
 221 //------------------------------------------------------------------------
 222
 223 class GfxFontDict {
 224 public:
 225
 226   // Build the font dictionary, given the PDF font dictionary.
 227   GfxFontDict(Dict *fontDict);
 228
 229   // Destructor.
 230   ~GfxFontDict();
 231
 232   // Get the specified font.
 233   GfxFont *lookup(char *tag);
 234
 235   // Iterative access.
 236   int getNumFonts() { return numFonts; }
 237   GfxFont *getFont(int i) { return fonts[i]; }
 238
 239 private:
 240
 241   GfxFont **fonts;              // list of fonts
 242   int numFonts;                 // number of fonts
 243 };
 244
 245 #endif