Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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.