PageRenderTime 15ms CodeModel.GetById 1ms app.highlight 9ms RepoModel.GetById 2ms app.codeStats 0ms

/src/compiler/android-ndk/jni/freetype/src/truetype/ttobjs.h

http://ftk.googlecode.com/
C++ Header | 431 lines | 149 code | 101 blank | 181 comment | 0 complexity | f6ae522e0c2ee7182712636d3323da62 MD5 | raw file
  1/***************************************************************************/
  2/*                                                                         */
  3/*  ttobjs.h                                                               */
  4/*                                                                         */
  5/*    Objects manager (specification).                                     */
  6/*                                                                         */
  7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
  8/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  9/*                                                                         */
 10/*  This file is part of the FreeType project, and may only be used,       */
 11/*  modified, and distributed under the terms of the FreeType project      */
 12/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 13/*  this file you indicate that you have read the license and              */
 14/*  understand and accept it fully.                                        */
 15/*                                                                         */
 16/***************************************************************************/
 17
 18
 19#ifndef __TTOBJS_H__
 20#define __TTOBJS_H__
 21
 22
 23#include <ft2build.h>
 24#include FT_INTERNAL_OBJECTS_H
 25#include FT_INTERNAL_TRUETYPE_TYPES_H
 26
 27
 28FT_BEGIN_HEADER
 29
 30
 31  /*************************************************************************/
 32  /*                                                                       */
 33  /* <Type>                                                                */
 34  /*    TT_Driver                                                          */
 35  /*                                                                       */
 36  /* <Description>                                                         */
 37  /*    A handle to a TrueType driver object.                              */
 38  /*                                                                       */
 39  typedef struct TT_DriverRec_*  TT_Driver;
 40
 41
 42  /*************************************************************************/
 43  /*                                                                       */
 44  /* <Type>                                                                */
 45  /*    TT_Instance                                                        */
 46  /*                                                                       */
 47  /* <Description>                                                         */
 48  /*    A handle to a TrueType size object.                                */
 49  /*                                                                       */
 50  typedef struct TT_SizeRec_*  TT_Size;
 51
 52
 53  /*************************************************************************/
 54  /*                                                                       */
 55  /* <Type>                                                                */
 56  /*    TT_GlyphSlot                                                       */
 57  /*                                                                       */
 58  /* <Description>                                                         */
 59  /*    A handle to a TrueType glyph slot object.                          */
 60  /*                                                                       */
 61  /* <Note>                                                                */
 62  /*    This is a direct typedef of FT_GlyphSlot, as there is nothing      */
 63  /*    specific about the TrueType glyph slot.                            */
 64  /*                                                                       */
 65  typedef FT_GlyphSlot  TT_GlyphSlot;
 66
 67
 68  /*************************************************************************/
 69  /*                                                                       */
 70  /* <Struct>                                                              */
 71  /*    TT_GraphicsState                                                   */
 72  /*                                                                       */
 73  /* <Description>                                                         */
 74  /*    The TrueType graphics state used during bytecode interpretation.   */
 75  /*                                                                       */
 76  typedef struct  TT_GraphicsState_
 77  {
 78    FT_UShort      rp0;
 79    FT_UShort      rp1;
 80    FT_UShort      rp2;
 81
 82    FT_UnitVector  dualVector;
 83    FT_UnitVector  projVector;
 84    FT_UnitVector  freeVector;
 85
 86#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
 87    FT_Bool        both_x_axis;
 88#endif
 89
 90    FT_Long        loop;
 91    FT_F26Dot6     minimum_distance;
 92    FT_Int         round_state;
 93
 94    FT_Bool        auto_flip;
 95    FT_F26Dot6     control_value_cutin;
 96    FT_F26Dot6     single_width_cutin;
 97    FT_F26Dot6     single_width_value;
 98    FT_Short       delta_base;
 99    FT_Short       delta_shift;
100
101    FT_Byte        instruct_control;
102    /* According to Greg Hitchcock from Microsoft, the `scan_control'     */
103    /* variable as documented in the TrueType specification is a 32-bit   */
104    /* integer; the high-word part holds the SCANTYPE value, the low-word */
105    /* part the SCANCTRL value.  We separate it into two fields.          */
106    FT_Bool        scan_control;
107    FT_Int         scan_type;
108
109    FT_UShort      gep0;
110    FT_UShort      gep1;
111    FT_UShort      gep2;
112
113  } TT_GraphicsState;
114
115
116#ifdef TT_USE_BYTECODE_INTERPRETER
117
118  FT_LOCAL( void )
119  tt_glyphzone_done( TT_GlyphZone  zone );
120
121  FT_LOCAL( FT_Error )
122  tt_glyphzone_new( FT_Memory     memory,
123                    FT_UShort     maxPoints,
124                    FT_Short      maxContours,
125                    TT_GlyphZone  zone );
126
127#endif /* TT_USE_BYTECODE_INTERPRETER */
128
129
130
131  /*************************************************************************/
132  /*                                                                       */
133  /*  EXECUTION SUBTABLES                                                  */
134  /*                                                                       */
135  /*  These sub-tables relate to instruction execution.                    */
136  /*                                                                       */
137  /*************************************************************************/
138
139
140#define TT_MAX_CODE_RANGES  3
141
142
143  /*************************************************************************/
144  /*                                                                       */
145  /* There can only be 3 active code ranges at once:                       */
146  /*   - the Font Program                                                  */
147  /*   - the CVT Program                                                   */
148  /*   - a glyph's instructions set                                        */
149  /*                                                                       */
150  typedef enum  TT_CodeRange_Tag_
151  {
152    tt_coderange_none = 0,
153    tt_coderange_font,
154    tt_coderange_cvt,
155    tt_coderange_glyph
156
157  } TT_CodeRange_Tag;
158
159
160  typedef struct  TT_CodeRange_
161  {
162    FT_Byte*  base;
163    FT_ULong  size;
164
165  } TT_CodeRange;
166
167  typedef TT_CodeRange  TT_CodeRangeTable[TT_MAX_CODE_RANGES];
168
169
170  /*************************************************************************/
171  /*                                                                       */
172  /* Defines a function/instruction definition record.                     */
173  /*                                                                       */
174  typedef struct  TT_DefRecord_
175  {
176    FT_Int   range;      /* in which code range is it located? */
177    FT_Long  start;      /* where does it start?               */
178    FT_UInt  opc;        /* function #, or instruction code    */
179    FT_Bool  active;     /* is it active?                      */
180
181  } TT_DefRecord, *TT_DefArray;
182
183
184  /*************************************************************************/
185  /*                                                                       */
186  /* Subglyph transformation record.                                       */
187  /*                                                                       */
188  typedef struct  TT_Transform_
189  {
190    FT_Fixed    xx, xy;     /* transformation matrix coefficients */
191    FT_Fixed    yx, yy;
192    FT_F26Dot6  ox, oy;     /* offsets        */
193
194  } TT_Transform;
195
196
197  /*************************************************************************/
198  /*                                                                       */
199  /* A note regarding non-squared pixels:                                  */
200  /*                                                                       */
201  /* (This text will probably go into some docs at some time; for now, it  */
202  /* is kept here to explain some definitions in the TT_Size_Metrics       */
203  /* record).                                                              */
204  /*                                                                       */
205  /* The CVT is a one-dimensional array containing values that control     */
206  /* certain important characteristics in a font, like the height of all   */
207  /* capitals, all lowercase letter, default spacing or stem width/height. */
208  /*                                                                       */
209  /* These values are found in FUnits in the font file, and must be scaled */
210  /* to pixel coordinates before being used by the CVT and glyph programs. */
211  /* Unfortunately, when using distinct x and y resolutions (or distinct x */
212  /* and y pointsizes), there are two possible scalings.                   */
213  /*                                                                       */
214  /* A first try was to implement a `lazy' scheme where all values were    */
215  /* scaled when first used.  However, while some values are always used   */
216  /* in the same direction, some others are used under many different      */
217  /* circumstances and orientations.                                       */
218  /*                                                                       */
219  /* I have found a simpler way to do the same, and it even seems to work  */
220  /* in most of the cases:                                                 */
221  /*                                                                       */
222  /* - All CVT values are scaled to the maximum ppem size.                 */
223  /*                                                                       */
224  /* - When performing a read or write in the CVT, a ratio factor is used  */
225  /*   to perform adequate scaling.  Example:                              */
226  /*                                                                       */
227  /*     x_ppem = 14                                                       */
228  /*     y_ppem = 10                                                       */
229  /*                                                                       */
230  /*   We choose ppem = x_ppem = 14 as the CVT scaling size.  All cvt      */
231  /*   entries are scaled to it.                                           */
232  /*                                                                       */
233  /*     x_ratio = 1.0                                                     */
234  /*     y_ratio = y_ppem/ppem (< 1.0)                                     */
235  /*                                                                       */
236  /*   We compute the current ratio like:                                  */
237  /*                                                                       */
238  /*   - If projVector is horizontal,                                      */
239  /*       ratio = x_ratio = 1.0                                           */
240  /*                                                                       */
241  /*   - if projVector is vertical,                                        */
242  /*       ratio = y_ratio                                                 */
243  /*                                                                       */
244  /*   - else,                                                             */
245  /*       ratio = sqrt( (proj.x * x_ratio) ^ 2 + (proj.y * y_ratio) ^ 2 ) */
246  /*                                                                       */
247  /*   Reading a cvt value returns                                         */
248  /*     ratio * cvt[index]                                                */
249  /*                                                                       */
250  /*   Writing a cvt value in pixels:                                      */
251  /*     cvt[index] / ratio                                                */
252  /*                                                                       */
253  /*   The current ppem is simply                                          */
254  /*     ratio * ppem                                                      */
255  /*                                                                       */
256  /*************************************************************************/
257
258
259  /*************************************************************************/
260  /*                                                                       */
261  /* Metrics used by the TrueType size and context objects.                */
262  /*                                                                       */
263  typedef struct  TT_Size_Metrics_
264  {
265    /* for non-square pixels */
266    FT_Long     x_ratio;
267    FT_Long     y_ratio;
268
269    FT_UShort   ppem;               /* maximum ppem size              */
270    FT_Long     ratio;              /* current ratio                  */
271    FT_Fixed    scale;
272
273    FT_F26Dot6  compensations[4];   /* device-specific compensations  */
274
275    FT_Bool     valid;
276
277    FT_Bool     rotated;            /* `is the glyph rotated?'-flag   */
278    FT_Bool     stretched;          /* `is the glyph stretched?'-flag */
279
280  } TT_Size_Metrics;
281
282
283  /*************************************************************************/
284  /*                                                                       */
285  /* TrueType size class.                                                  */
286  /*                                                                       */
287  typedef struct  TT_SizeRec_
288  {
289    FT_SizeRec         root;
290
291    /* we have our own copy of metrics so that we can modify */
292    /* it without affecting auto-hinting (when used)         */
293    FT_Size_Metrics    metrics;
294
295    TT_Size_Metrics    ttmetrics;
296
297    FT_ULong           strike_index;      /* 0xFFFFFFFF to indicate invalid */
298
299#ifdef TT_USE_BYTECODE_INTERPRETER
300
301    FT_UInt            num_function_defs; /* number of function definitions */
302    FT_UInt            max_function_defs;
303    TT_DefArray        function_defs;     /* table of function definitions  */
304
305    FT_UInt            num_instruction_defs;  /* number of ins. definitions */
306    FT_UInt            max_instruction_defs;
307    TT_DefArray        instruction_defs;      /* table of ins. definitions  */
308
309    FT_UInt            max_func;
310    FT_UInt            max_ins;
311
312    TT_CodeRangeTable  codeRangeTable;
313
314    TT_GraphicsState   GS;
315
316    FT_ULong           cvt_size;      /* the scaled control value table */
317    FT_Long*           cvt;
318
319    FT_UShort          storage_size; /* The storage area is now part of */
320    FT_Long*           storage;      /* the instance                    */
321
322    TT_GlyphZoneRec    twilight;     /* The instance's twilight zone    */
323
324    /* debugging variables */
325
326    /* When using the debugger, we must keep the */
327    /* execution context tied to the instance    */
328    /* object rather than asking it on demand.   */
329
330    FT_Bool            debug;
331    TT_ExecContext     context;
332
333    FT_Bool            bytecode_ready;
334    FT_Bool            cvt_ready;
335
336#endif /* TT_USE_BYTECODE_INTERPRETER */
337
338  } TT_SizeRec;
339
340
341  /*************************************************************************/
342  /*                                                                       */
343  /* TrueType driver class.                                                */
344  /*                                                                       */
345  typedef struct  TT_DriverRec_
346  {
347    FT_DriverRec     root;
348    TT_ExecContext   context;  /* execution context        */
349    TT_GlyphZoneRec  zone;     /* glyph loader points zone */
350
351    void*            extension_component;
352
353  } TT_DriverRec;
354
355
356  /* Note: All of the functions below (except tt_size_reset()) are used    */
357  /* as function pointers in a FT_Driver_ClassRec.  Therefore their        */
358  /* parameters are of types FT_Face, FT_Size, etc., rather than TT_Face,  */
359  /* TT_Size, etc., so that the compiler can confirm that the types and    */
360  /* number of parameters are correct.  In all cases the FT_xxx types are  */
361  /* cast to their TT_xxx counterparts inside the functions since FreeType */
362  /* will always use the TT driver to create them.                         */
363
364
365  /*************************************************************************/
366  /*                                                                       */
367  /* Face functions                                                        */
368  /*                                                                       */
369  FT_LOCAL( FT_Error )
370  tt_face_init( FT_Stream      stream,
371                FT_Face        ttface,      /* TT_Face */
372                FT_Int         face_index,
373                FT_Int         num_params,
374                FT_Parameter*  params );
375
376  FT_LOCAL( void )
377  tt_face_done( FT_Face  ttface );          /* TT_Face */
378
379
380  /*************************************************************************/
381  /*                                                                       */
382  /* Size functions                                                        */
383  /*                                                                       */
384  FT_LOCAL( FT_Error )
385  tt_size_init( FT_Size  ttsize );          /* TT_Size */
386
387  FT_LOCAL( void )
388  tt_size_done( FT_Size  ttsize );          /* TT_Size */
389
390#ifdef TT_USE_BYTECODE_INTERPRETER
391
392  FT_LOCAL( FT_Error )
393  tt_size_run_fpgm( TT_Size  size );
394
395  FT_LOCAL( FT_Error )
396  tt_size_run_prep( TT_Size  size );
397
398  FT_LOCAL( FT_Error )
399  tt_size_ready_bytecode( TT_Size  size );
400
401#endif /* TT_USE_BYTECODE_INTERPRETER */
402
403  FT_LOCAL( FT_Error )
404  tt_size_reset( TT_Size  size );
405
406
407  /*************************************************************************/
408  /*                                                                       */
409  /* Driver functions                                                      */
410  /*                                                                       */
411  FT_LOCAL( FT_Error )
412  tt_driver_init( FT_Module  ttdriver );    /* TT_Driver */
413
414  FT_LOCAL( void )
415  tt_driver_done( FT_Module  ttdriver );    /* TT_Driver */
416
417
418  /*************************************************************************/
419  /*                                                                       */
420  /* Slot functions                                                        */
421  /*                                                                       */
422  FT_LOCAL( FT_Error )
423  tt_slot_init( FT_GlyphSlot  slot );
424
425
426FT_END_HEADER
427
428#endif /* __TTOBJS_H__ */
429
430
431/* END */