source: trunk/poppler/mypoppler/poppler/GfxFont.h @ 27

Last change on this file since 27 was 27, checked in by Eugene Romanenko, 16 years ago

poppler updated to version 0.5.2, also needed changes to be compatible with new poppler

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