Home | History | Annotate | Download | only in freetype
      1 /***************************************************************************/
      2 /*                                                                         */
      3 /*  fttypes.h                                                              */
      4 /*                                                                         */
      5 /*    FreeType simple types definitions (specification only).              */
      6 /*                                                                         */
      7 /*  Copyright 1996-2001, 2002, 2004, 2006, 2007, 2008 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 FT_CONFIG_CONFIG_H
     25 #include FT_SYSTEM_H
     26 #include FT_IMAGE_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 float 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 float 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 float 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 float 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   /*    Most 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 
    575   /* return base error code (without module-specific prefix) */
    576 #define FT_ERROR_BASE( x )    ( (x) & 0xFF )
    577 
    578   /* return module error code */
    579 #define FT_ERROR_MODULE( x )  ( (x) & 0xFF00U )
    580 
    581 #define FT_BOOL( x )  ( (FT_Bool)( x ) )
    582 
    583 FT_END_HEADER
    584 
    585 #endif /* __FTTYPES_H__ */
    586 
    587 
    588 /* END */
    589