include/fttypes.h

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