XFA: merge patch from CL 817753002
[pdfium.git] / core / src / fxge / fx_freetype / fxft2.5.01 / include / freetype / fttypes.h
1 /***************************************************************************/
2 /*                                                                         */
3 /*  fttypes.h                                                              */
4 /*                                                                         */
5 /*    FreeType simple types definitions (specification only).              */
6 /*                                                                         */
7 /*  Copyright 1996-2002, 2004, 2006-2009, 2012, 2013 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 __FTTYPES_H__
20 #define __FTTYPES_H__
21
22
23 #include "../ft2build.h"
24 #include "config/ftconfig.h"
25 #include "ftsystem.h"
26 #include "ftimage.h"
27
28 #include <stddef.h>
29
30
31 FT_BEGIN_HEADER
32
33
34   /*************************************************************************/
35   /*                                                                       */
36   /* <Section>                                                             */
37   /*    basic_types                                                        */
38   /*                                                                       */
39   /* <Title>                                                               */
40   /*    Basic Data Types                                                   */
41   /*                                                                       */
42   /* <Abstract>                                                            */
43   /*    The basic data types defined by the library.                       */
44   /*                                                                       */
45   /* <Description>                                                         */
46   /*    This section contains the basic data types defined by FreeType~2,  */
47   /*    ranging from simple scalar types to bitmap descriptors.  More      */
48   /*    font-specific structures are defined in a different section.       */
49   /*                                                                       */
50   /* <Order>                                                               */
51   /*    FT_Byte                                                            */
52   /*    FT_Bytes                                                           */
53   /*    FT_Char                                                            */
54   /*    FT_Int                                                             */
55   /*    FT_UInt                                                            */
56   /*    FT_Int16                                                           */
57   /*    FT_UInt16                                                          */
58   /*    FT_Int32                                                           */
59   /*    FT_UInt32                                                          */
60   /*    FT_Short                                                           */
61   /*    FT_UShort                                                          */
62   /*    FT_Long                                                            */
63   /*    FT_ULong                                                           */
64   /*    FT_Bool                                                            */
65   /*    FT_Offset                                                          */
66   /*    FT_PtrDist                                                         */
67   /*    FT_String                                                          */
68   /*    FT_Tag                                                             */
69   /*    FT_Error                                                           */
70   /*    FT_Fixed                                                           */
71   /*    FT_Pointer                                                         */
72   /*    FT_Pos                                                             */
73   /*    FT_Vector                                                          */
74   /*    FT_BBox                                                            */
75   /*    FT_Matrix                                                          */
76   /*    FT_FWord                                                           */
77   /*    FT_UFWord                                                          */
78   /*    FT_F2Dot14                                                         */
79   /*    FT_UnitVector                                                      */
80   /*    FT_F26Dot6                                                         */
81   /*                                                                       */
82   /*                                                                       */
83   /*    FT_Generic                                                         */
84   /*    FT_Generic_Finalizer                                               */
85   /*                                                                       */
86   /*    FT_Bitmap                                                          */
87   /*    FT_Pixel_Mode                                                      */
88   /*    FT_Palette_Mode                                                    */
89   /*    FT_Glyph_Format                                                    */
90   /*    FT_IMAGE_TAG                                                       */
91   /*                                                                       */
92   /*************************************************************************/
93
94
95   /*************************************************************************/
96   /*                                                                       */
97   /* <Type>                                                                */
98   /*    FT_Bool                                                            */
99   /*                                                                       */
100   /* <Description>                                                         */
101   /*    A typedef of unsigned char, used for simple booleans.  As usual,   */
102   /*    values 1 and~0 represent true and false, respectively.             */
103   /*                                                                       */
104   typedef unsigned char  FT_Bool;
105
106
107   /*************************************************************************/
108   /*                                                                       */
109   /* <Type>                                                                */
110   /*    FT_FWord                                                           */
111   /*                                                                       */
112   /* <Description>                                                         */
113   /*    A signed 16-bit integer used to store a distance in original font  */
114   /*    units.                                                             */
115   /*                                                                       */
116   typedef signed short  FT_FWord;   /* distance in FUnits */
117
118
119   /*************************************************************************/
120   /*                                                                       */
121   /* <Type>                                                                */
122   /*    FT_UFWord                                                          */
123   /*                                                                       */
124   /* <Description>                                                         */
125   /*    An unsigned 16-bit integer used to store a distance in original    */
126   /*    font units.                                                        */
127   /*                                                                       */
128   typedef unsigned short  FT_UFWord;  /* unsigned distance */
129
130
131   /*************************************************************************/
132   /*                                                                       */
133   /* <Type>                                                                */
134   /*    FT_Char                                                            */
135   /*                                                                       */
136   /* <Description>                                                         */
137   /*    A simple typedef for the _signed_ char type.                       */
138   /*                                                                       */
139   typedef signed char  FT_Char;
140
141
142   /*************************************************************************/
143   /*                                                                       */
144   /* <Type>                                                                */
145   /*    FT_Byte                                                            */
146   /*                                                                       */
147   /* <Description>                                                         */
148   /*    A simple typedef for the _unsigned_ char type.                     */
149   /*                                                                       */
150   typedef unsigned char  FT_Byte;
151
152
153   /*************************************************************************/
154   /*                                                                       */
155   /* <Type>                                                                */
156   /*    FT_Bytes                                                           */
157   /*                                                                       */
158   /* <Description>                                                         */
159   /*    A typedef for constant memory areas.                               */
160   /*                                                                       */
161   typedef const FT_Byte*  FT_Bytes;
162
163
164   /*************************************************************************/
165   /*                                                                       */
166   /* <Type>                                                                */
167   /*    FT_Tag                                                             */
168   /*                                                                       */
169   /* <Description>                                                         */
170   /*    A typedef for 32-bit tags (as used in the SFNT format).            */
171   /*                                                                       */
172   typedef FT_UInt32  FT_Tag;
173
174
175   /*************************************************************************/
176   /*                                                                       */
177   /* <Type>                                                                */
178   /*    FT_String                                                          */
179   /*                                                                       */
180   /* <Description>                                                         */
181   /*    A simple typedef for the char type, usually used for strings.      */
182   /*                                                                       */
183   typedef char  FT_String;
184
185
186   /*************************************************************************/
187   /*                                                                       */
188   /* <Type>                                                                */
189   /*    FT_Short                                                           */
190   /*                                                                       */
191   /* <Description>                                                         */
192   /*    A typedef for signed short.                                        */
193   /*                                                                       */
194   typedef signed short  FT_Short;
195
196
197   /*************************************************************************/
198   /*                                                                       */
199   /* <Type>                                                                */
200   /*    FT_UShort                                                          */
201   /*                                                                       */
202   /* <Description>                                                         */
203   /*    A typedef for unsigned short.                                      */
204   /*                                                                       */
205   typedef unsigned short  FT_UShort;
206
207
208   /*************************************************************************/
209   /*                                                                       */
210   /* <Type>                                                                */
211   /*    FT_Int                                                             */
212   /*                                                                       */
213   /* <Description>                                                         */
214   /*    A typedef for the int type.                                        */
215   /*                                                                       */
216   typedef signed int  FT_Int;
217
218
219   /*************************************************************************/
220   /*                                                                       */
221   /* <Type>                                                                */
222   /*    FT_UInt                                                            */
223   /*                                                                       */
224   /* <Description>                                                         */
225   /*    A typedef for the unsigned int type.                               */
226   /*                                                                       */
227   typedef unsigned int  FT_UInt;
228
229
230   /*************************************************************************/
231   /*                                                                       */
232   /* <Type>                                                                */
233   /*    FT_Long                                                            */
234   /*                                                                       */
235   /* <Description>                                                         */
236   /*    A typedef for signed long.                                         */
237   /*                                                                       */
238   typedef signed long  FT_Long;
239
240
241   /*************************************************************************/
242   /*                                                                       */
243   /* <Type>                                                                */
244   /*    FT_ULong                                                           */
245   /*                                                                       */
246   /* <Description>                                                         */
247   /*    A typedef for unsigned long.                                       */
248   /*                                                                       */
249   typedef unsigned long  FT_ULong;
250
251
252   /*************************************************************************/
253   /*                                                                       */
254   /* <Type>                                                                */
255   /*    FT_F2Dot14                                                         */
256   /*                                                                       */
257   /* <Description>                                                         */
258   /*    A signed 2.14 fixed-point type used for unit vectors.              */
259   /*                                                                       */
260   typedef signed short  FT_F2Dot14;
261
262
263   /*************************************************************************/
264   /*                                                                       */
265   /* <Type>                                                                */
266   /*    FT_F26Dot6                                                         */
267   /*                                                                       */
268   /* <Description>                                                         */
269   /*    A signed 26.6 fixed-point type used for vectorial pixel            */
270   /*    coordinates.                                                       */
271   /*                                                                       */
272   typedef signed long  FT_F26Dot6;
273
274
275   /*************************************************************************/
276   /*                                                                       */
277   /* <Type>                                                                */
278   /*    FT_Fixed                                                           */
279   /*                                                                       */
280   /* <Description>                                                         */
281   /*    This type is used to store 16.16 fixed-point values, like scaling  */
282   /*    values or matrix coefficients.                                     */
283   /*                                                                       */
284   typedef signed long  FT_Fixed;
285
286
287   /*************************************************************************/
288   /*                                                                       */
289   /* <Type>                                                                */
290   /*    FT_Error                                                           */
291   /*                                                                       */
292   /* <Description>                                                         */
293   /*    The FreeType error code type.  A value of~0 is always interpreted  */
294   /*    as a successful operation.                                         */
295   /*                                                                       */
296   typedef int  FT_Error;
297
298
299   /*************************************************************************/
300   /*                                                                       */
301   /* <Type>                                                                */
302   /*    FT_Pointer                                                         */
303   /*                                                                       */
304   /* <Description>                                                         */
305   /*    A simple typedef for a typeless pointer.                           */
306   /*                                                                       */
307   typedef void*  FT_Pointer;
308
309
310   /*************************************************************************/
311   /*                                                                       */
312   /* <Type>                                                                */
313   /*    FT_Offset                                                          */
314   /*                                                                       */
315   /* <Description>                                                         */
316   /*    This is equivalent to the ANSI~C `size_t' type, i.e., the largest  */
317   /*    _unsigned_ integer type used to express a file size or position,   */
318   /*    or a memory block size.                                            */
319   /*                                                                       */
320   typedef size_t  FT_Offset;
321
322
323   /*************************************************************************/
324   /*                                                                       */
325   /* <Type>                                                                */
326   /*    FT_PtrDist                                                         */
327   /*                                                                       */
328   /* <Description>                                                         */
329   /*    This is equivalent to the ANSI~C `ptrdiff_t' type, i.e., the       */
330   /*    largest _signed_ integer type used to express the distance         */
331   /*    between two pointers.                                              */
332   /*                                                                       */
333   typedef ft_ptrdiff_t  FT_PtrDist;
334
335
336   /*************************************************************************/
337   /*                                                                       */
338   /* <Struct>                                                              */
339   /*    FT_UnitVector                                                      */
340   /*                                                                       */
341   /* <Description>                                                         */
342   /*    A simple structure used to store a 2D vector unit vector.  Uses    */
343   /*    FT_F2Dot14 types.                                                  */
344   /*                                                                       */
345   /* <Fields>                                                              */
346   /*    x :: Horizontal coordinate.                                        */
347   /*                                                                       */
348   /*    y :: Vertical coordinate.                                          */
349   /*                                                                       */
350   typedef struct  FT_UnitVector_
351   {
352     FT_F2Dot14  x;
353     FT_F2Dot14  y;
354
355   } FT_UnitVector;
356
357
358   /*************************************************************************/
359   /*                                                                       */
360   /* <Struct>                                                              */
361   /*    FT_Matrix                                                          */
362   /*                                                                       */
363   /* <Description>                                                         */
364   /*    A simple structure used to store a 2x2 matrix.  Coefficients are   */
365   /*    in 16.16 fixed-point format.  The computation performed is:        */
366   /*                                                                       */
367   /*       {                                                               */
368   /*          x' = x*xx + y*xy                                             */
369   /*          y' = x*yx + y*yy                                             */
370   /*       }                                                               */
371   /*                                                                       */
372   /* <Fields>                                                              */
373   /*    xx :: Matrix coefficient.                                          */
374   /*                                                                       */
375   /*    xy :: Matrix coefficient.                                          */
376   /*                                                                       */
377   /*    yx :: Matrix coefficient.                                          */
378   /*                                                                       */
379   /*    yy :: Matrix coefficient.                                          */
380   /*                                                                       */
381   typedef struct  FT_Matrix_
382   {
383     FT_Fixed  xx, xy;
384     FT_Fixed  yx, yy;
385
386   } FT_Matrix;
387
388
389   /*************************************************************************/
390   /*                                                                       */
391   /* <Struct>                                                              */
392   /*    FT_Data                                                            */
393   /*                                                                       */
394   /* <Description>                                                         */
395   /*    Read-only binary data represented as a pointer and a length.       */
396   /*                                                                       */
397   /* <Fields>                                                              */
398   /*    pointer :: The data.                                               */
399   /*                                                                       */
400   /*    length  :: The length of the data in bytes.                        */
401   /*                                                                       */
402   typedef struct  FT_Data_
403   {
404     const FT_Byte*  pointer;
405     FT_Int          length;
406
407   } FT_Data;
408
409
410   /*************************************************************************/
411   /*                                                                       */
412   /* <FuncType>                                                            */
413   /*    FT_Generic_Finalizer                                               */
414   /*                                                                       */
415   /* <Description>                                                         */
416   /*    Describe a function used to destroy the `client' data of any       */
417   /*    FreeType object.  See the description of the @FT_Generic type for  */
418   /*    details of usage.                                                  */
419   /*                                                                       */
420   /* <Input>                                                               */
421   /*    The address of the FreeType object which is under finalization.    */
422   /*    Its client data is accessed through its `generic' field.           */
423   /*                                                                       */
424   typedef void  (*FT_Generic_Finalizer)(void*  object);
425
426
427   /*************************************************************************/
428   /*                                                                       */
429   /* <Struct>                                                              */
430   /*    FT_Generic                                                         */
431   /*                                                                       */
432   /* <Description>                                                         */
433   /*    Client applications often need to associate their own data to a    */
434   /*    variety of FreeType core objects.  For example, a text layout API  */
435   /*    might want to associate a glyph cache to a given size object.      */
436   /*                                                                       */
437   /*    Some FreeType object contains a `generic' field, of type           */
438   /*    FT_Generic, which usage is left to client applications and font    */
439   /*    servers.                                                           */
440   /*                                                                       */
441   /*    It can be used to store a pointer to client-specific data, as well */
442   /*    as the address of a `finalizer' function, which will be called by  */
443   /*    FreeType when the object is destroyed (for example, the previous   */
444   /*    client example would put the address of the glyph cache destructor */
445   /*    in the `finalizer' field).                                         */
446   /*                                                                       */
447   /* <Fields>                                                              */
448   /*    data      :: A typeless pointer to any client-specified data. This */
449   /*                 field is completely ignored by the FreeType library.  */
450   /*                                                                       */
451   /*    finalizer :: A pointer to a `generic finalizer' function, which    */
452   /*                 will be called when the object is destroyed.  If this */
453   /*                 field is set to NULL, no code will be called.         */
454   /*                                                                       */
455   typedef struct  FT_Generic_
456   {
457     void*                 data;
458     FT_Generic_Finalizer  finalizer;
459
460   } FT_Generic;
461
462
463   /*************************************************************************/
464   /*                                                                       */
465   /* <Macro>                                                               */
466   /*    FT_MAKE_TAG                                                        */
467   /*                                                                       */
468   /* <Description>                                                         */
469   /*    This macro converts four-letter tags which are used to label       */
470   /*    TrueType tables into an unsigned long to be used within FreeType.  */
471   /*                                                                       */
472   /* <Note>                                                                */
473   /*    The produced values *must* be 32-bit integers.  Don't redefine     */
474   /*    this macro.                                                        */
475   /*                                                                       */
476 #define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
477           (FT_Tag)                        \
478           ( ( (FT_ULong)_x1 << 24 ) |     \
479             ( (FT_ULong)_x2 << 16 ) |     \
480             ( (FT_ULong)_x3 <<  8 ) |     \
481               (FT_ULong)_x4         )
482
483
484   /*************************************************************************/
485   /*************************************************************************/
486   /*                                                                       */
487   /*                    L I S T   M A N A G E M E N T                      */
488   /*                                                                       */
489   /*************************************************************************/
490   /*************************************************************************/
491
492
493   /*************************************************************************/
494   /*                                                                       */
495   /* <Section>                                                             */
496   /*    list_processing                                                    */
497   /*                                                                       */
498   /*************************************************************************/
499
500
501   /*************************************************************************/
502   /*                                                                       */
503   /* <Type>                                                                */
504   /*    FT_ListNode                                                        */
505   /*                                                                       */
506   /* <Description>                                                         */
507   /*     Many elements and objects in FreeType are listed through an       */
508   /*     @FT_List record (see @FT_ListRec).  As its name suggests, an      */
509   /*     FT_ListNode is a handle to a single list element.                 */
510   /*                                                                       */
511   typedef struct FT_ListNodeRec_*  FT_ListNode;
512
513
514   /*************************************************************************/
515   /*                                                                       */
516   /* <Type>                                                                */
517   /*    FT_List                                                            */
518   /*                                                                       */
519   /* <Description>                                                         */
520   /*    A handle to a list record (see @FT_ListRec).                       */
521   /*                                                                       */
522   typedef struct FT_ListRec_*  FT_List;
523
524
525   /*************************************************************************/
526   /*                                                                       */
527   /* <Struct>                                                              */
528   /*    FT_ListNodeRec                                                     */
529   /*                                                                       */
530   /* <Description>                                                         */
531   /*    A structure used to hold a single list element.                    */
532   /*                                                                       */
533   /* <Fields>                                                              */
534   /*    prev :: The previous element in the list.  NULL if first.          */
535   /*                                                                       */
536   /*    next :: The next element in the list.  NULL if last.               */
537   /*                                                                       */
538   /*    data :: A typeless pointer to the listed object.                   */
539   /*                                                                       */
540   typedef struct  FT_ListNodeRec_
541   {
542     FT_ListNode  prev;
543     FT_ListNode  next;
544     void*        data;
545
546   } FT_ListNodeRec;
547
548
549   /*************************************************************************/
550   /*                                                                       */
551   /* <Struct>                                                              */
552   /*    FT_ListRec                                                         */
553   /*                                                                       */
554   /* <Description>                                                         */
555   /*    A structure used to hold a simple doubly-linked list.  These are   */
556   /*    used in many parts of FreeType.                                    */
557   /*                                                                       */
558   /* <Fields>                                                              */
559   /*    head :: The head (first element) of doubly-linked list.            */
560   /*                                                                       */
561   /*    tail :: The tail (last element) of doubly-linked list.             */
562   /*                                                                       */
563   typedef struct  FT_ListRec_
564   {
565     FT_ListNode  head;
566     FT_ListNode  tail;
567
568   } FT_ListRec;
569
570
571   /* */
572
573 #define FT_IS_EMPTY( list )  ( (list).head == 0 )
574 #define FT_BOOL( x )  ( (FT_Bool)( x ) )
575
576   /* concatenate C tokens */
577 #define FT_ERR_XCAT( x, y )  x ## y
578 #define FT_ERR_CAT( x, y )   FT_ERR_XCAT( x, y )
579
580   /* see `ftmoderr.h' for descriptions of the following macros */
581
582 #define FT_ERR( e )  FT_ERR_CAT( FT_ERR_PREFIX, e )
583
584 #define FT_ERROR_BASE( x )    ( (x) & 0xFF )
585 #define FT_ERROR_MODULE( x )  ( (x) & 0xFF00U )
586
587 #define FT_ERR_EQ( x, e )                                        \
588           ( FT_ERROR_BASE( x ) == FT_ERROR_BASE( FT_ERR( e ) ) )
589 #define FT_ERR_NEQ( x, e )                                       \
590           ( FT_ERROR_BASE( x ) != FT_ERROR_BASE( FT_ERR( e ) ) )
591
592
593 FT_END_HEADER
594
595 #endif /* __FTTYPES_H__ */
596
597
598 /* END */