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

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 15 years ago

First import

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  // Get font tag.
119  GooString *getTag() { return tag; }
120
121  // Get font dictionary ID.
122  Ref *getID() { return &id; }
123
124  // Does this font match the tag?
125  GBool matches(char *tagA) { return !tag->cmp(tagA); }
126
127  // Get base font name.
128  GooString *getName() { return name; }
129 
130  // Get font family name.
131  GooString *getFamily() { return family; }
132 
133  // Get font stretch.
134  Stretch getStretch() { return stretch; }
135 
136  // Get font weight.
137  Weight getWeight() { return weight; }
138
139  // Get the original font name (ignornig any munging that might have
140  // been done to map to a canonical Base-14 font name).
141  GooString *getOrigName() { return origName; }
142
143  // Get font type.
144  GfxFontType getType() { return type; }
145  virtual GBool isCIDFont() { return gFalse; }
146
147  // Get embedded font ID, i.e., a ref for the font file stream.
148  // Returns false if there is no embedded font.
149  GBool getEmbeddedFontID(Ref *embID)
150    { *embID = embFontID; return embFontID.num >= 0; }
151
152  // Get the PostScript font name for the embedded font.  Returns
153  // NULL if there is no embedded font.
154  GooString *getEmbeddedFontName() { return embFontName; }
155
156  // Get the name of the external font file.  Returns NULL if there
157  // is no external font file.
158  GooString *getExtFontFile() { return extFontFile; }
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  // Return the font matrix.
168  double *getFontMatrix() { return fontMat; }
169
170  // Return the font bounding box.
171  double *getFontBBox() { return fontBBox; }
172
173  // Return the ascent and descent values.
174  double getAscent() { return ascent; }
175  double getDescent() { return descent; }
176
177  // Return the writing mode (0=horizontal, 1=vertical).
178  virtual int getWMode() { return 0; }
179
180  // Read an external or embedded font file into a buffer.
181  char *readExtFontFile(int *len);
182  char *readEmbFontFile(XRef *xref, int *len);
183
184  // Get the next char from a string <s> of <len> bytes, returning the
185  // char <code>, its Unicode mapping <u>, its displacement vector
186  // (<dx>, <dy>), and its origin offset vector (<ox>, <oy>).  <uSize>
187  // is the number of entries available in <u>, and <uLen> is set to
188  // the number actually used.  Returns the number of bytes used by
189  // the char code.
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) = 0;
193
194protected:
195
196  void readFontDescriptor(XRef *xref, Dict *fontDict);
197  CharCodeToUnicode *readToUnicodeCMap(Dict *fontDict, int nBits,
198                                       CharCodeToUnicode *ctu);
199  void findExtFontFile();
200
201  GooString *tag;                       // PDF font tag
202  Ref id;                       // reference (used as unique ID)
203  GooString *name;              // font name
204  GooString *family;            // font family
205  Stretch stretch;                      // font stretch
206  Weight weight;                        // font weight
207  GooString *origName;          // original font name
208  GfxFontType type;             // type of font
209  int flags;                    // font descriptor flags
210  GooString *embFontName;               // name of embedded font
211  Ref embFontID;                // ref to embedded font file stream
212  GooString *extFontFile;               // external font file name
213  double fontMat[6];            // font matrix (Type 3 only)
214  double fontBBox[4];           // font bounding box (Type 3 only)
215  double missingWidth;          // "default" width
216  double ascent;                // max height above baseline
217  double descent;               // max depth below baseline
218  GBool ok;
219};
220
221//------------------------------------------------------------------------
222// Gfx8BitFont
223//------------------------------------------------------------------------
224
225class Gfx8BitFont: public GfxFont {
226public:
227
228  Gfx8BitFont(XRef *xref, char *tagA, Ref idA, GooString *nameA,
229              GfxFontType typeA, Dict *fontDict);
230
231  virtual ~Gfx8BitFont();
232
233  virtual int getNextChar(char *s, int len, CharCode *code,
234                          Unicode *u, int uSize, int *uLen,
235                          double *dx, double *dy, double *ox, double *oy);
236
237  // Return the encoding.
238  char **getEncoding() { return enc; }
239
240  // Return the Unicode map.
241  CharCodeToUnicode *getToUnicode();
242
243  // Return the character name associated with <code>.
244  char *getCharName(int code) { return enc[code]; }
245
246  // Returns true if the PDF font specified an encoding.
247  GBool getHasEncoding() { return hasEncoding; }
248
249  // Returns true if the PDF font specified MacRomanEncoding.
250  GBool getUsesMacRomanEnc() { return usesMacRomanEnc; }
251
252  // Get width of a character.
253  double getWidth(Guchar c) { return widths[c]; }
254
255  // Return a char code-to-GID mapping for the provided font file.
256  // (This is only useful for TrueType fonts.)
257  Gushort *getCodeToGIDMap(FoFiTrueType *ff);
258
259  // Return the Type 3 CharProc dictionary, or NULL if none.
260  Dict *getCharProcs();
261
262  // Return the Type 3 CharProc for the character associated with <code>.
263  Object *getCharProc(int code, Object *proc);
264
265  // Return the Type 3 Resources dictionary, or NULL if none.
266  Dict *getResources();
267
268private:
269
270  char *enc[256];               // char code --> char name
271  char encFree[256];            // boolean for each char name: if set,
272                                //   the string is malloc'ed
273  CharCodeToUnicode *ctu;       // char code --> Unicode
274  GBool hasEncoding;
275  GBool usesMacRomanEnc;
276  double widths[256];           // character widths
277  Object charProcs;             // Type 3 CharProcs dictionary
278  Object resources;             // Type 3 Resources dictionary
279};
280
281//------------------------------------------------------------------------
282// GfxCIDFont
283//------------------------------------------------------------------------
284
285class GfxCIDFont: public GfxFont {
286public:
287
288  GfxCIDFont(XRef *xref, char *tagA, Ref idA, GooString *nameA,
289             Dict *fontDict);
290
291  virtual ~GfxCIDFont();
292
293  virtual GBool isCIDFont() { return gTrue; }
294
295  virtual int getNextChar(char *s, int len, CharCode *code,
296                          Unicode *u, int uSize, int *uLen,
297                          double *dx, double *dy, double *ox, double *oy);
298
299  // Return the writing mode (0=horizontal, 1=vertical).
300  virtual int getWMode();
301
302  // Return the Unicode map.
303  CharCodeToUnicode *getToUnicode();
304
305  // Get the collection name (<registry>-<ordering>).
306  GooString *getCollection();
307
308  // Return the CID-to-GID mapping table.  These should only be called
309  // if type is fontCIDType2.
310  Gushort *getCIDToGID() { return cidToGID; }
311  int getCIDToGIDLen() { return cidToGIDLen; }
312
313  Gushort *getCodeToGIDMap(FoFiTrueType *ff, int *length);
314
315private:
316
317  CMap *cMap;                   // char code --> CID
318  CharCodeToUnicode *ctu;       // CID --> Unicode
319  GfxFontCIDWidths widths;      // character widths
320  Gushort *cidToGID;            // CID --> GID mapping (for embedded
321                                //   TrueType fonts)
322  int cidToGIDLen;
323};
324
325//------------------------------------------------------------------------
326// GfxFontDict
327//------------------------------------------------------------------------
328
329class GfxFontDict {
330public:
331
332  // Build the font dictionary, given the PDF font dictionary.
333  GfxFontDict(XRef *xref, Ref *fontDictRef, Dict *fontDict);
334
335  // Destructor.
336  ~GfxFontDict();
337
338  // Get the specified font.
339  GfxFont *lookup(char *tag);
340
341  // Iterative access.
342  int getNumFonts() { return numFonts; }
343  GfxFont *getFont(int i) { return fonts[i]; }
344
345private:
346
347  GfxFont **fonts;              // list of fonts
348  int numFonts;                 // number of fonts
349};
350
351#endif
Note: See TracBrowser for help on using the repository browser.