XFA: merge patch from CL 815103002
[pdfium.git] / third_party / freetype / src / cff / cf2hints.h
1 /***************************************************************************/
2 /*                                                                         */
3 /*  cf2hints.h                                                             */
4 /*                                                                         */
5 /*    Adobe's code for handling CFF hints (body).                          */
6 /*                                                                         */
7 /*  Copyright 2007-2013 Adobe Systems Incorporated.                        */
8 /*                                                                         */
9 /*  This software, and all works of authorship, whether in source or       */
10 /*  object code form as indicated by the copyright notice(s) included      */
11 /*  herein (collectively, the "Work") is made available, and may only be   */
12 /*  used, modified, and distributed under the FreeType Project License,    */
13 /*  LICENSE.TXT.  Additionally, subject to the terms and conditions of the */
14 /*  FreeType Project License, each contributor to the Work hereby grants   */
15 /*  to any individual or legal entity exercising permissions granted by    */
16 /*  the FreeType Project License and this section (hereafter, "You" or     */
17 /*  "Your") a perpetual, worldwide, non-exclusive, no-charge,              */
18 /*  royalty-free, irrevocable (except as stated in this section) patent    */
19 /*  license to make, have made, use, offer to sell, sell, import, and      */
20 /*  otherwise transfer the Work, where such license applies only to those  */
21 /*  patent claims licensable by such contributor that are necessarily      */
22 /*  infringed by their contribution(s) alone or by combination of their    */
23 /*  contribution(s) with the Work to which such contribution(s) was        */
24 /*  submitted.  If You institute patent litigation against any entity      */
25 /*  (including a cross-claim or counterclaim in a lawsuit) alleging that   */
26 /*  the Work or a contribution incorporated within the Work constitutes    */
27 /*  direct or contributory patent infringement, then any patent licenses   */
28 /*  granted to You under this License for that Work shall terminate as of  */
29 /*  the date such litigation is filed.                                     */
30 /*                                                                         */
31 /*  By using, modifying, or distributing the Work you indicate that you    */
32 /*  have read and understood the terms and conditions of the               */
33 /*  FreeType Project License as well as those provided in this section,    */
34 /*  and you accept them fully.                                             */
35 /*                                                                         */
36 /***************************************************************************/
37
38
39 #ifndef __CF2HINTS_H__
40 #define __CF2HINTS_H__
41
42
43 FT_BEGIN_HEADER
44
45
46   enum
47   {
48     CF2_MAX_HINTS = 96    /* maximum # of hints */
49   };
50
51
52   /*
53    * A HintMask object stores a bit mask that specifies which hints in the
54    * charstring are active at a given time.  Hints in CFF must be declared
55    * at the start, before any drawing operators, with horizontal hints
56    * preceding vertical hints.  The HintMask is ordered the same way, with
57    * horizontal hints immediately followed by vertical hints.  Clients are
58    * responsible for knowing how many of each type are present.
59    *
60    * The maximum total number of hints is 96, as specified by the CFF
61    * specification.
62    *
63    * A HintMask is built 0 or more times while interpreting a charstring, by
64    * the HintMask operator.  There is only one HintMask, but it is built or
65    * rebuilt each time there is a hint substitution (HintMask operator) in
66    * the charstring.  A default HintMask with all bits set is built if there
67    * has been no HintMask operator prior to the first drawing operator.
68    *
69    */
70
71   typedef struct  CF2_HintMaskRec_
72   {
73     FT_Error*  error;
74
75     FT_Bool  isValid;
76     FT_Bool  isNew;
77
78     size_t  bitCount;
79     size_t  byteCount;
80
81     FT_Byte  mask[( CF2_MAX_HINTS + 7 ) / 8];
82
83   } CF2_HintMaskRec, *CF2_HintMask;
84
85
86   typedef struct  CF2_StemHintRec_
87   {
88     FT_Bool  used;     /* DS positions are valid         */
89
90     CF2_Fixed  min;    /* original character space value */
91     CF2_Fixed  max;
92
93     CF2_Fixed  minDS;  /* DS position after first use    */
94     CF2_Fixed  maxDS;
95
96   } CF2_StemHintRec, *CF2_StemHint;
97
98
99   /*
100    * A HintMap object stores a piecewise linear function for mapping
101    * y-coordinates from character space to device space, providing
102    * appropriate pixel alignment to stem edges.
103    *
104    * The map is implemented as an array of `CF2_Hint' elements, each
105    * representing an edge.  When edges are paired, as from stem hints, the
106    * bottom edge must immediately precede the top edge in the array.
107    * Element character space AND device space positions must both increase
108    * monotonically in the array.  `CF2_Hint' elements are also used as
109    * parameters to `cf2_blues_capture'.
110    *
111    * The `cf2_hintmap_build' method must be called before any drawing
112    * operation (beginning with a Move operator) and at each hint
113    * substitution (HintMask operator).
114    *
115    * The `cf2_hintmap_map' method is called to transform y-coordinates at
116    * each drawing operation (move, line, curve).
117    *
118    */
119
120   /* TODO: make this a CF2_ArrStack and add a deep copy method */
121   enum
122   {
123     CF2_MAX_HINT_EDGES = CF2_MAX_HINTS * 2
124   };
125
126
127   typedef struct  CF2_HintMapRec_
128   {
129     CF2_Font  font;
130
131     /* initial map based on blue zones */
132     struct CF2_HintMapRec_*  initialHintMap;
133
134     /* working storage for 2nd pass adjustHints */
135     CF2_ArrStack  hintMoves;
136
137     FT_Bool  isValid;
138     FT_Bool  hinted;
139
140     CF2_Fixed  scale;
141     CF2_UInt   count;
142
143     /* start search from this index */
144     CF2_UInt  lastIndex;
145
146     CF2_HintRec  edge[CF2_MAX_HINT_EDGES]; /* 192 */
147
148   } CF2_HintMapRec, *CF2_HintMap;
149
150
151   FT_LOCAL( FT_Bool )
152   cf2_hint_isValid( const CF2_Hint  hint );
153   FT_LOCAL( FT_Bool )
154   cf2_hint_isTop( const CF2_Hint  hint );
155   FT_LOCAL( FT_Bool )
156   cf2_hint_isBottom( const CF2_Hint  hint );
157   FT_LOCAL( void )
158   cf2_hint_lock( CF2_Hint  hint );
159
160
161   FT_LOCAL( void )
162   cf2_hintmap_init( CF2_HintMap   hintmap,
163                     CF2_Font      font,
164                     CF2_HintMap   initialMap,
165                     CF2_ArrStack  hintMoves,
166                     CF2_Fixed     scale );
167   FT_LOCAL( void )
168   cf2_hintmap_build( CF2_HintMap   hintmap,
169                      CF2_ArrStack  hStemHintArray,
170                      CF2_ArrStack  vStemHintArray,
171                      CF2_HintMask  hintMask,
172                      CF2_Fixed     hintOrigin,
173                      FT_Bool       initialMap );
174
175
176   /*
177    * GlyphPath is a wrapper for drawing operations that scales the
178    * coordinates according to the render matrix and HintMap.  It also tracks
179    * open paths to control ClosePath and to insert MoveTo for broken fonts.
180    *
181    */
182   typedef struct  CF2_GlyphPathRec_
183   {
184     /* TODO: gather some of these into a hinting context */
185
186     CF2_Font              font;           /* font instance    */
187     CF2_OutlineCallbacks  callbacks;      /* outline consumer */
188
189
190     CF2_HintMapRec  hintMap;        /* current hint map            */
191     CF2_HintMapRec  firstHintMap;   /* saved copy                  */
192     CF2_HintMapRec  initialHintMap; /* based on all captured hints */
193
194     CF2_ArrStackRec  hintMoves;  /* list of hint moves for 2nd pass */
195
196     CF2_Fixed  scaleX;         /* matrix a */
197     CF2_Fixed  scaleC;         /* matrix c */
198     CF2_Fixed  scaleY;         /* matrix d */
199
200     FT_Vector  fractionalTranslation;  /* including deviceXScale */
201 #if 0
202     CF2_Fixed  hShift;    /* character space horizontal shift */
203                           /* (for fauxing)                    */
204 #endif
205
206     FT_Bool  pathIsOpen;     /* true after MoveTo                     */
207     FT_Bool  pathIsClosing;  /* true when synthesizing closepath line */
208     FT_Bool  darken;         /* true if stem darkening                */
209     FT_Bool  moveIsPending;  /* true between MoveTo and offset MoveTo */
210
211     /* references used to call `cf2_hintmap_build', if necessary */
212     CF2_ArrStack         hStemHintArray;
213     CF2_ArrStack         vStemHintArray;
214     CF2_HintMask         hintMask;     /* ptr to the current mask */
215     CF2_Fixed            hintOriginY;  /* copy of current origin  */
216     const CF2_BluesRec*  blues;
217
218     CF2_Fixed  xOffset;        /* character space offsets */
219     CF2_Fixed  yOffset;
220
221     /* character space miter limit threshold */
222     CF2_Fixed  miterLimit;
223     /* vertical/horzizontal snap distance in character space */
224     CF2_Fixed  snapThreshold;
225
226     FT_Vector  offsetStart0;  /* first and second points of first */
227     FT_Vector  offsetStart1;  /* element with offset applied      */
228
229     /* current point, character space, before offset */
230     FT_Vector  currentCS;
231     /* current point, device space */
232     FT_Vector  currentDS;
233     /* start point of subpath, character space */
234     FT_Vector  start;
235
236     /* the following members constitute the `queue' of one element */
237     FT_Bool  elemIsQueued;
238     CF2_Int  prevElemOp;
239
240     FT_Vector  prevElemP0;
241     FT_Vector  prevElemP1;
242     FT_Vector  prevElemP2;
243     FT_Vector  prevElemP3;
244
245   } CF2_GlyphPathRec, *CF2_GlyphPath;
246
247
248   FT_LOCAL( void )
249   cf2_glyphpath_init( CF2_GlyphPath         glyphpath,
250                       CF2_Font              font,
251                       CF2_OutlineCallbacks  callbacks,
252                       CF2_Fixed             scaleY,
253                       /* CF2_Fixed hShift, */
254                       CF2_ArrStack          hStemHintArray,
255                       CF2_ArrStack          vStemHintArray,
256                       CF2_HintMask          hintMask,
257                       CF2_Fixed             hintOrigin,
258                       const CF2_Blues       blues,
259                       const FT_Vector*      fractionalTranslation );
260   FT_LOCAL( void )
261   cf2_glyphpath_finalize( CF2_GlyphPath  glyphpath );
262
263   FT_LOCAL( void )
264   cf2_glyphpath_moveTo( CF2_GlyphPath  glyphpath,
265                         CF2_Fixed      x,
266                         CF2_Fixed      y );
267   FT_LOCAL( void )
268   cf2_glyphpath_lineTo( CF2_GlyphPath  glyphpath,
269                         CF2_Fixed      x,
270                         CF2_Fixed      y );
271   FT_LOCAL( void )
272   cf2_glyphpath_curveTo( CF2_GlyphPath  glyphpath,
273                          CF2_Fixed      x1,
274                          CF2_Fixed      y1,
275                          CF2_Fixed      x2,
276                          CF2_Fixed      y2,
277                          CF2_Fixed      x3,
278                          CF2_Fixed      y3 );
279   FT_LOCAL( void )
280   cf2_glyphpath_closeOpenPath( CF2_GlyphPath  glyphpath );
281
282
283 FT_END_HEADER
284
285
286 #endif /* __CF2HINTS_H__ */
287
288
289 /* END */