← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/freetype/src/truetype/ttobjs.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/freetype/src/truetype/ttobjs.h
 
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
 
 
28
FT_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
 
 
426
FT_END_HEADER
 
427
 
 
428
#endif /* __TTOBJS_H__ */
 
429
 
 
430
 
 
431
/* END */