/***************************************************************************//*                                                                         *//*  ftoption.h                                                             *//*                                                                         *//*    User-selectable configuration macros (specification only).           *//*                                                                         *//*  Copyright 1996-2001 by                                                 *//*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *//*                                                                         *//*  This file is part of the FreeType project, and may only be used,       *//*  modified, and distributed under the terms of the FreeType project      *//*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *//*  this file you indicate that you have read the license and              *//*  understand and accept it fully.                                        *//*                                                                         *//***************************************************************************/#ifndef __FTOPTION_H__#define __FTOPTION_H__#include <ft2build.h>FT_BEGIN_HEADER  /*************************************************************************/  /*                                                                       */  /*                 USER-SELECTABLE CONFIGURATION MACROS                  */  /*                                                                       */  /* This file contains the default configuration macro definitions for    */  /* a standard build of the FreeType library.  There are three ways to    */  /* use this file to build project-specific versions of the library:      */  /*                                                                       */  /*  - You can modify this file by hand, but this is not recommended in   */  /*    cases where you would like to build several versions of the        */  /*    library from a single source directory.                            */  /*                                                                       */  /*  - You can put a copy of this file in your build directory, more      */  /*    precisely in "$BUILD/freetype/config/ftoption.h", where "$BUILD"   */  /*    is the name of a directory that is included _before_ the FreeType  */  /*    include path during compilation.                                   */  /*                                                                       */  /*    The default FreeType Makefiles and Jamfiles use the build          */  /*    directory "builds/<system>" by default, but you can easily change  */  /*    that for your own projects.                                        */  /*                                                                       */  /*  - Copy the file <ft2build.h> to "$BUILD/ft2build.h" and modify it    */  /*    slightly to pre-define the macro FT_CONFIG_OPTIONS_H used to       */  /*    locate this file during the build.  For example,                   */  /*                                                                       */  /*      #define FT_CONFIG_OPTIONS_H  <myftoptions.h>                     */  /*      #include <freetype/config/ftheader.h>                            */  /*                                                                       */  /*    will use "$BUILD/myftoptions.h" instead of this file for macro     */  /*    definitions.                                                       */  /*                                                                       */  /*    Note also that you can similarly pre-define the macro              */  /*    FT_CONFIG_MODULES_H used to locate the file listing of the modules */  /*    that are statically linked to the library at compile time.  By     */  /*    default, this file is <freetype/config/ftmodule.h>.                */  /*                                                                       */  /*  We highly recommend using the third method whenever possible.        */  /*                                                                       */  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/  /****                                                                 ****/  /**** G E N E R A L   F R E E T Y P E   2   C O N F I G U R A T I O N ****/  /****                                                                 ****/  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/  /*                                                                       */  /* Convenience functions support                                         */  /*                                                                       */  /*   Some functions of the FreeType 2 API are provided as a convenience  */  /*   for client applications and developers. However,  they are not      */  /*   required to build and run the library itself.                       */  /*                                                                       */  /*   By defining this configuration macro, you'll disable the            */  /*   compilation of these functions at build time.  This can be useful   */  /*   to reduce the library's code size when you don't need any of        */  /*   these functions.                                                    */  /*                                                                       */  /*   All convenience functions are declared as such in their             */  /*   documentation.                                                      */  /*                                                                       */#undef FT_CONFIG_OPTION_NO_CONVENIENCE_FUNCS  /*************************************************************************/  /*                                                                       */  /* Module errors                                                         */  /*                                                                       */  /*   If this macro is set (which is _not_ the default), the higher byte  */  /*   of an error code gives the module in which the error has occurred,  */  /*   while the lower byte is the real error code.                        */  /*                                                                       */  /*   Setting this macro makes sense for debugging purposes only, since   */  /*   it would break source compatibility of certain programs that use    */  /*   FreeType 2.                                                         */  /*                                                                       */  /*   More details can be found in the files ftmoderr.h and fterrors.h.   */  /*                                                                       */#undef FT_CONFIG_OPTION_USE_MODULE_ERRORS  /*************************************************************************/  /*                                                                       */  /* Alternate Glyph Image Format support                                  */  /*                                                                       */  /*   By default, the glyph images returned by the FreeType glyph loader  */  /*   can either be a pixmap or a vectorial outline defined through       */  /*   Bezier control points.  When defining the following configuration   */  /*   macro, some font drivers will be able to register alternate         */  /*   glyph image formats.                                                */  /*                                                                       */  /*   Unset this macro if you are sure that you will never use a font     */  /*   driver with an alternate glyph format; this will reduce the size of */  /*   the base layer code.                                                */  /*                                                                       */  /*   Note that a few Type 1 fonts, as well as Windows `vector' fonts     */  /*   use a vector `plotter' format that isn't supported when this        */  /*   macro is undefined.                                                 */  /*                                                                       */#define FT_CONFIG_OPTION_ALTERNATE_GLYPH_FORMATS  /*************************************************************************/  /*                                                                       */  /* Glyph Postscript Names handling                                       */  /*                                                                       */  /*   By default, FreeType 2 is compiled with the `PSNames' module.  This */  /*   module is in charge of converting a glyph name string into a        */  /*   Unicode value, or return a Macintosh standard glyph name for the    */  /*   use with the TrueType `post' table.                                 */  /*                                                                       */  /*   Undefine this macro if you do not want `PSNames' compiled in your   */  /*   build of FreeType.  This has the following effects:                 */  /*                                                                       */  /*   - The TrueType driver will provide its own set of glyph names,      */  /*     if you build it to support postscript names in the TrueType       */  /*     `post' table.                                                     */  /*                                                                       */  /*   - The Type 1 driver will not be able to synthetize a Unicode        */  /*     charmap out of the glyphs found in the fonts.                     */  /*                                                                       */  /*   You would normally undefine this configuration macro when building  */  /*   a version of FreeType that doesn't contain a Type 1 or CFF driver.  */  /*                                                                       */#define FT_CONFIG_OPTION_POSTSCRIPT_NAMES  /*************************************************************************/  /*                                                                       */  /* Postscript Names to Unicode Values support                            */  /*                                                                       */  /*   By default, FreeType 2 is built with the `PSNames' module compiled  */  /*   in.  Among other things, the module is used to convert a glyph name */  /*   into a Unicode value.  This is especially useful in order to        */  /*   synthetize on the fly a Unicode charmap from the CFF/Type 1 driver  */  /*   through a big table named the `Adobe Glyph List' (AGL).             */  /*                                                                       */  /*   Undefine this macro if you do not want the Adobe Glyph List         */  /*   compiled in your `PSNames' module.  The Type 1 driver will not be   */  /*   able to synthetize a Unicode charmap out of the glyphs found in the */  /*   fonts.                                                              */  /*                                                                       */#define FT_CONFIG_OPTION_ADOBE_GLYPH_LIST  /*************************************************************************/  /*                                                                       */  /* Many compilers provide a non-ANSI 64-bit data type that can be used   */  /* by FreeType to speed up some computations.  However, this will create */  /* some problems when compiling the library in strict ANSI mode.         */  /*                                                                       */  /* For this reason, the use of 64-bit ints is normally disabled when     */  /* the __STDC__ macro is defined.  You can however disable this by       */  /* defining here the macro FT_CONFIG_OPTION_FORCE_INT64.                 */  /*                                                                       */  /* For most compilers, this will only create compilation warnings        */  /* when building the library.                                            */  /*                                                                       */  /* ObNote: The compiler-specific 64-bit integers are detected in the     */  /*         file "ftconfig.h" either statically, or through Autoconf      */  /*         on platforms that support it.                                 */  /*                                                                       */#undef FT_CONFIG_OPTION_FORCE_INT64  /*************************************************************************/  /*                                                                       */  /* DLL export compilation                                                */  /*                                                                       */  /*   When compiling FreeType as a DLL, some systems/compilers need a     */  /*   special keyword in front OR after the return type of function       */  /*   declarations.                                                       */  /*                                                                       */  /*   Two macros are used within the FreeType source code to define       */  /*   exported library functions: FT_EXPORT and FT_EXPORT_DEF.            */  /*                                                                       */  /*     FT_EXPORT( return_type )                                          */  /*                                                                       */  /*       is used in a function declaration, as in                        */  /*                                                                       */  /*         FT_EXPORT( FT_Error )                                         */  /*         FT_Init_FreeType( FT_Library*  alibrary );                    */  /*                                                                       */  /*                                                                       */  /*     FT_EXPORT_DEF( return_type )                                      */  /*                                                                       */  /*       is used in a function definition, as in                         */  /*                                                                       */  /*         FT_EXPORT_DEF( FT_Error )                                     */  /*         FT_Init_FreeType( FT_Library*  alibrary )                     */  /*         {                                                             */  /*           ... some code ...                                           */  /*           return FT_Err_Ok;                                           */  /*         }                                                             */  /*                                                                       */  /*   You can provide your own implementation of FT_EXPORT and            */  /*   FT_EXPORT_DEF here if you want.  If you leave them undefined, they  */  /*   will be later automatically defined as `extern return_type' to      */  /*   allow normal compilation.                                           */  /*                                                                       */