libraries/freetype-2.0.5/include/freetype/config/ftheader.h

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftheader.h                                                             */
   4 /*                                                                         */
   5 /*    Build macros of the FreeType 2 library.                              */
   6 /*                                                                         */
   7 /*  Copyright 1996-2001 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 #ifndef __FT_HEADER_H__
  19 #define __FT_HEADER_H__
  20
  21   /*************************************************************************/
  22   /*                                                                       */
  23   /* <Macro>                                                               */
  24   /*    FT_BEGIN_HEADER                                                    */
  25   /*                                                                       */
  26   /* <Description>                                                         */
  27   /*    This macro is used in association with @FT_END_HEADER in header    */
  28   /*    files to ensure that the declarations within are properly          */
  29   /*    encapsulated in an `extern "C" { .. }' block when included from a  */
  30   /*    C++ compiler.                                                      */
  31   /*                                                                       */
  32 #ifdef __cplusplus
  33 #define FT_BEGIN_HEADER  extern "C" {
  34 #else
  35 #define FT_BEGIN_HEADER  /* nothing */
  36 #endif
  37
  38
  39   /*************************************************************************/
  40   /*                                                                       */
  41   /* <Macro>                                                               */
  42   /*    FT_END_HEADER                                                      */
  43   /*                                                                       */
  44   /* <Description>                                                         */
  45   /*    This macro is used in association with @FT_BEGIN_HEADER in header  */
  46   /*    files to ensure that the declarations within are properly          */
  47   /*    encapsulated in an `extern "C" { .. }' block when included from a  */
  48   /*    C++ compiler.                                                      */
  49   /*                                                                       */
  50 #ifdef __cplusplus
  51 #define FT_END_HEADER  }
  52 #else
  53 #define FT_END_HEADER  /* nothing */
  54 #endif
  55
  56
  57   /*************************************************************************/
  58   /*                                                                       */
  59   /* Aliases for the FreeType 2 public and configuration files.            */
  60   /*                                                                       */
  61   /*************************************************************************/
  62
  63   /*************************************************************************/
  64   /*                                                                       */
  65   /* <Section>                                                             */
  66   /*    header_file_macros                                                 */
  67   /*                                                                       */
  68   /* <Title>                                                               */
  69   /*    Header File Macros                                                 */
  70   /*                                                                       */
  71   /* <Abstract>                                                            */
  72   /*    Macro definitions used to #include specific header files.          */
  73   /*                                                                       */
  74   /* <Description>                                                         */
  75   /*    The following macros are defined to the name of specific           */
  76   /*    FreeType 2 header files.  They can be used directly in #include    */
  77   /*    statements as in:                                                  */
  78   /*                                                                       */
  79   /*    {                                                                  */
  80   /*      #include FT_FREETYPE_H                                           */
  81   /*      #include FT_MULTIPLE_MASTERS_H                                   */
  82   /*      #include FT_GLYPH_H                                              */
  83   /*    }                                                                  */
  84   /*                                                                       */
  85   /*    There are several reasons why we are now using macros to name      */
  86   /*    public header files.  The first one is that such macros are not    */
  87   /*    limited to the infamous 8.3 naming rule required by DOS (and       */
  88   /*    `FT_MULTIPLE_MASTERS_H' is a lot more meaningful than `ftmm.h').   */
  89   /*                                                                       */
  90   /*    The second reason is that is allows for more flexibility in the    */
  91   /*    way FreeType 2 is installed on a given system.                     */
  92   /*                                                                       */
  93   /*************************************************************************/
  94
  95   /* configuration files */
  96
  97   /*************************************************************************/
  98   /*                                                                       */
  99   /* @macro:                                                               */
 100   /*    FT_CONFIG_CONFIG_H                                                 */
 101   /*                                                                       */
 102   /* @description:                                                         */
 103   /*    A macro used in #include statements to name the file containing    */
 104   /*    FreeType 2 configuration data.                                     */
 105   /*                                                                       */
 106 #ifndef FT_CONFIG_CONFIG_H
 107 #define FT_CONFIG_CONFIG_H  <freetype/config/ftconfig.h>
 108 #endif
 109
 110
 111   /*************************************************************************/
 112   /*                                                                       */
 113   /* @macro:                                                               */
 114   /*    FT_CONFIG_OPTIONS_H                                                */
 115   /*                                                                       */
 116   /* @description:                                                         */
 117   /*    A macro used in #include statements to name the file containing    */
 118   /*    FreeType 2 project-specific configuration options.                 */
 119   /*                                                                       */
 120 #ifndef FT_CONFIG_OPTIONS_H
 121 #define FT_CONFIG_OPTIONS_H  <freetype/config/ftoption.h>
 122 #endif
 123
 124
 125   /*************************************************************************/
 126   /*                                                                       */
 127   /* @macro:                                                               */
 128   /*    FT_CONFIG_MODULES_H                                                */
 129   /*                                                                       */
 130   /* @description:                                                         */
 131   /*    A macro used in #include statements to name the file containing    */
 132   /*    the list of FreeType 2 modules that are statically linked to new   */
 133   /*    library instances in @FT_Init_FreeType.                            */
 134   /*                                                                       */
 135 #ifndef FT_CONFIG_MODULES_H
 136 #define FT_CONFIG_MODULES_H  <freetype/config/ftmodule.h>
 137 #endif
 138
 139   /* public headers */
 140
 141   /*************************************************************************/
 142   /*                                                                       */
 143   /* @macro:                                                               */
 144   /*    FT_FREETYPE_H                                                      */
 145   /*                                                                       */
 146   /* @description:                                                         */
 147   /*    A macro used in #include statements to name the file containing    */
 148   /*    the base FreeType 2 API.                                           */
 149   /*                                                                       */
 150 #define FT_FREETYPE_H  <freetype/freetype.h>
 151
 152
 153   /*************************************************************************/
 154   /*                                                                       */
 155   /* @macro:                                                               */
 156   /*    FT_ERRORS_H                                                        */
 157   /*                                                                       */
 158   /* @description:                                                         */
 159   /*    A macro used in #include statements to name the file containing    */
 160   /*    the list of FreeType 2 error codes (and messages).                 */
 161   /*                                                                       */
 162   /*    It is included by @FT_FREETYPE_H.                                  */
 163   /*                                                                       */
 164 #define FT_ERRORS_H  <freetype/fterrors.h>
 165
 166
 167   /*************************************************************************/
 168   /*                                                                       */
 169   /* @macro:                                                               */
 170   /*    FT_MODULE_ERRORS_H                                                 */
 171   /*                                                                       */
 172   /* @description:                                                         */
 173   /*    A macro used in #include statements to name the file containing    */
 174   /*    the list of FreeType 2 module error offsets (and messages).        */
 175   /*                                                                       */
 176 #define FT_MODULE_ERRORS_H  <freetype/ftmoderr.h>
 177
 178
 179   /*************************************************************************/
 180   /*                                                                       */
 181   /* @macro:                                                               */
 182   /*    FT_SYSTEM_H                                                        */
 183   /*                                                                       */
 184   /* @description:                                                         */
 185   /*    A macro used in #include statements to name the file containing    */
 186   /*    the FreeType 2 interface to low-level operations (i.e. memory      */
 187   /*    management and stream i/o).                                        */
 188   /*                                                                       */
 189   /*    It is included by @FT_FREETYPE_H.                                  */
 190   /*                                                                       */
 191 #define FT_SYSTEM_H  <freetype/ftsystem.h>
 192
 193
 194   /*************************************************************************/
 195   /*                                                                       */
 196   /* @macro:                                                               */
 197   /*    FT_IMAGE_H                                                         */
 198   /*                                                                       */
 199   /* @description:                                                         */
 200   /*    A macro used in #include statements to name the file containing    */
 201   /*    types definitions related to glyph images (i.e. bitmaps, outlines, */
 202   /*    scan-converter parameters).                                        */
 203   /*                                                                       */
 204   /*    It is included by @FT_FREETYPE_H.                                  */
 205   /*                                                                       */
 206 #define FT_IMAGE_H  <freetype/ftimage.h>
 207
 208
 209   /*************************************************************************/
 210   /*                                                                       */
 211   /* @macro:                                                               */
 212   /*    FT_TYPES_H                                                         */
 213   /*                                                                       */
 214   /* @description:                                                         */
 215   /*    A macro used in #include statements to name the file containing    */
 216   /*    the basic data types defined by FreeType 2.                        */
 217   /*                                                                       */
 218   /*    It is included by @FT_FREETYPE_H.                                  */
 219   /*                                                                       */
 220 #define FT_TYPES_H  <freetype/fttypes.h>
 221
 222
 223   /*************************************************************************/
 224   /*                                                                       */
 225   /* @macro:                                                               */
 226   /*    FT_LIST_H                                                          */
 227   /*                                                                       */
 228   /* @description:                                                         */
 229   /*    A macro used in #include statements to name the file containing    */
 230   /*    the list management API of FreeType 2.                             */
 231   /*                                                                       */
 232   /*    (Most applications will never need to include this file.)          */
 233   /*                                                                       */
 234 #define FT_LIST_H  <freetype/ftlist.h>
 235
 236
 237   /*************************************************************************/
 238   /*                                                                       */
 239   /* @macro:                                                               */
 240   /*    FT_OUTLINE_H                                                       */
 241   /*                                                                       */
 242   /* @description:                                                         */
 243   /*    A macro used in #include statements to name the file containing    */
 244   /*    the scalable outline management API of FreeType 2.                 */
 245   /*                                                                       */
 246 #define FT_OUTLINE_H  <freetype/ftoutln.h>
 247
 248
 249   /*************************************************************************/
 250   /*                                                                       */
 251   /* @macro:                                                               */
 252   /*    FT_SIZES_H                                                         */
 253   /*                                                                       */
 254   /* @description:                                                         */
 255   /*    A macro used in #include statements to name the file containing    */
 256   /*    the API used to manage multiple @FT_Size objects per face.         */
 257   /*                                                                       */
 258 #define FT_SIZES_H  <freetype/ftsizes.h>
 259
 260
 261   /*************************************************************************/
 262   /*                                                                       */
 263   /* @macro:                                                               */
 264   /*    FT_MODULE_H                                                        */
 265   /*                                                                       */
 266   /* @description:                                                         */
 267   /*    A macro used in #include statements to name the file containing    */
 268   /*    the module management API of FreeType 2.                           */
 269   /*                                                                       */
 270 #define FT_MODULE_H  <freetype/ftmodule.h>
 271
 272
 273   /*************************************************************************/
 274   /*                                                                       */
 275   /* @macro:                                                               */
 276   /*    FT_RENDER_H                                                        */
 277   /*                                                                       */
 278   /* @description:                                                         */
 279   /*    A macro used in #include statements to name the file containing    */
 280   /*    the renderer module management API of FreeType 2.                  */
 281   /*                                                                       */
 282 #define FT_RENDER_H  <freetype/ftrender.h>
 283
 284
 285   /*************************************************************************/
 286   /*                                                                       */
 287   /* @macro:                                                               */
 288   /*    FT_TYPE1_TABLES_H                                                  */
 289   /*                                                                       */
 290   /* @description:                                                         */
 291   /*    A macro used in #include statements to name the file containing    */
 292   /*    the types and API specific to the Type 1 format.                   */
 293   /*                                                                       */
 294 #define FT_TYPE1_TABLES_H  <freetype/t1tables.h>
 295
 296
 297   /*************************************************************************/
 298   /*                                                                       */
 299   /* @macro:                                                               */
 300   /*    FT_TRUETYPE_IDS_H                                                  */
 301   /*                                                                       */
 302   /* @description:                                                         */
 303   /*    A macro used in #include statements to name the file containing    */
 304   /*    the enumeration values used to identify name strings, languages,   */
 305   /*    encodings, etc.  This file really contains a _large_ set of        */
 306   /*    constant macro definitions, taken from the TrueType and OpenType   */
 307   /*    specifications.                                                    */
 308   /*                                                                       */
 309 #define FT_TRUETYPE_IDS_H  <freetype/ttnameid.h>
 310
 311
 312   /*************************************************************************/
 313   /*                                                                       */
 314   /* @macro:                                                               */
 315   /*    FT_TRUETYPE_TABLES_H                                               */
 316   /*                                                                       */
 317   /* @description:                                                         */
 318   /*    A macro used in #include statements to name the file containing    */
 319   /*    the types and API specific to the TrueType (as well as OpenType)   */
 320   /*    format.                                                            */
 321   /*                                                                       */
 322 #define FT_TRUETYPE_TABLES_H  <freetype/tttables.h>
 323
 324
 325   /*************************************************************************/
 326   /*                                                                       */
 327   /* @macro:                                                               */
 328   /*    FT_TRUETYPE_TAGS_H                                                 */
 329   /*                                                                       */
 330   /* @description:                                                         */
 331   /*    A macro used in #include statements to name the file containing    */
 332   /*    the definitions of TrueType 4-byte `tags' used to identify blocks  */
 333   /*    in SFNT-based font formats (i.e. TrueType and OpenType).           */
 334   /*                                                                       */
 335 #define FT_TRUETYPE_TAGS_H  <freetype/tttags.h>
 336
 337
 338   /*************************************************************************/
 339   /*                                                                       */
 340   /* @macro:                                                               */
 341   /*    FT_GLYPH_H                                                         */
 342   /*                                                                       */
 343   /* @description:                                                         */
 344   /*    A macro used in #include statements to name the file containing    */
 345   /*    the API of the optional glyph management component.                */
 346   /*                                                                       */
 347 #define FT_GLYPH_H  <freetype/ftglyph.h>
 348
 349
 350   /*************************************************************************/
 351   /*                                                                       */
 352   /* @macro:                                                               */
 353   /*    FT_BBOX_H                                                          */
 354   /*                                                                       */
 355   /* @description:                                                         */
 356   /*    A macro used in #include statements to name the file containing    */
 357   /*    the API of the optional exact bounding box computation routines.   */
 358   /*                                                                       */
 359 #define FT_BBOX_H  <freetype/ftbbox.h>
 360
 361
 362   /*************************************************************************/
 363   /*                                                                       */
 364   /* @macro:                                                               */
 365   /*    FT_BEZIER_H                                                        */
 366   /*                                                                       */
 367   /* @description:                                                         */
 368   /*    A macro used in #include statements to name the file containing    */
 369   /*    a small useful API to handle bezier arcs.  Note that you _must_    */
 370   /*    include FT_FREETYPE_H or FT_IMAGE_H before this header.            */
 371   /*                                                                       */
 372 #define FT_BEZIER_H  <freetype/ftbezier.h>
 373
 374
 375   /*************************************************************************/
 376   /*                                                                       */
 377   /* @macro:                                                               */
 378   /*    FT_CACHE_H                                                         */
 379   /*                                                                       */
 380   /* @description:                                                         */
 381   /*    A macro used in #include statements to name the file containing    */
 382   /*    the API of the optional FreeType 2 cache sub-system.               */
 383   /*                                                                       */
 384 #define FT_CACHE_H  <freetype/ftcache.h>
 385
 386
 387   /*************************************************************************/
 388   /*                                                                       */
 389   /* @macro:                                                               */
 390   /*    FT_CACHE_IMAGE_H                                                   */
 391   /*                                                                       */
 392   /* @description:                                                         */
 393   /*    A macro used in #include statements to name the file containing    */
 394   /*    the `glyph image' API of the FreeType 2 cache sub-system.          */
 395   /*                                                                       */
 396   /*    It is used to define a cache for @FT_Glyph elements.  You can also */
 397   /*    see the API defined in @FT_CACHE_SMALL_BITMAPS_H if you only need  */
 398   /*    to store small glyph bitmaps, as it will use less memory.          */
 399   /*                                                                       */
 400 #define FT_CACHE_IMAGE_H  <freetype/cache/ftcimage.h>
 401
 402
 403   /*************************************************************************/
 404   /*                                                                       */
 405   /* @macro:                                                               */
 406   /*    FT_CACHE_SMALL_BITMAPS_H                                           */
 407   /*                                                                       */
 408   /* @description:                                                         */
 409   /*    A macro used in #include statements to name the file containing    */
 410   /*    the `small bitmaps' API of the FreeType 2 cache sub-system.        */
 411   /*                                                                       */
 412   /*    It is used to define a cache for small glyph bitmaps in a          */
 413   /*    relatively memory-efficient way.  You can also use the API defined */
 414   /*    in @FT_CACHE_IMAGE_H if you want to cache arbitrary glyph images,  */
 415   /*    including scalable outlines.                                       */
 416   /*                                                                       */
 417 #define FT_CACHE_SMALL_BITMAPS_H  <freetype/cache/ftcsbits.h>
 418
 419
 420   /*************************************************************************/
 421   /*                                                                       */
 422   /* @macro:                                                               */
 423   /*    FT_MAC_H                                                           */
 424   /*                                                                       */
 425   /* @description:                                                         */
 426   /*    A macro used in #include statements to name the file containing    */
 427   /*    the Macintosh-specific FreeType 2 API. The latter is used to       */
 428   /*    access fonts embedded in resource forks.                           */
 429   /*                                                                       */
 430   /*    This header file must be explicitly included by client             */
 431   /*    applications compiled on the Mac (note that the base API still     */
 432   /*    works though).                                                     */
 433   /*                                                                       */
 434 #define FT_MAC_H  <freetype/ftmac.h>
 435
 436
 437   /*************************************************************************/
 438   /*                                                                       */
 439   /* @macro:                                                               */
 440   /*    FT_MULTIPLE_MASTERS_H                                              */
 441   /*                                                                       */
 442   /* @description:                                                         */
 443   /*    A macro used in #include statements to name the file containing    */
 444   /*    the optional multiple-masters management API of FreeType 2.        */
 445   /*                                                                       */
 446 #define FT_MULTIPLE_MASTERS_H  <freetype/ftmm.h>
 447
 448
 449   /*************************************************************************/
 450   /*                                                                       */
 451   /* @macro:                                                               */
 452   /*    FT_SFNT_NAMES_H                                                    */
 453   /*                                                                       */
 454   /* @description:                                                         */
 455   /*    A macro used in #include statements to name the file containing    */
 456   /*    the optional FreeType 2 API used to access embedded `name' strings */
 457   /*    in SFNT-based font formats (i.e. TrueType and OpenType).           */
 458   /*                                                                       */
 459 #define FT_SFNT_NAMES_H  <freetype/ftsnames.h>
 460
 461   /* */
 462
 463 #define FT_TRIGONOMETRY_H          <freetype/fttrigon.h>
 464 #define FT_SYNTHESIS_H             <freetype/ftsynth.h>
 465
 466 #define FT_CACHE_MANAGER_H         <freetype/cache/ftcmanag.h>
 467
 468 #define FT_CACHE_INTERNAL_LRU_H    <freetype/cache/ftlru.h>
 469 #define FT_CACHE_INTERNAL_GLYPH_H  <freetype/cache/ftcglyph.h>
 470 #define FT_CACHE_INTERNAL_CHUNK_H  <freetype/cache/ftcchunk.h>
 471
 472   /* now include internal headers definitions from <freetype/internal/...> */
 473
 474 #define  FT_INTERNAL_INTERNAL_H    <freetype/internal/internal.h>
 475 #include FT_INTERNAL_INTERNAL_H
 476
 477
 478 #endif /* __FT2_BUILD_H__ */
 479
 480
 481 /* END */