/***************************************************************************//*                                                                         *//*  ftoption.h                                                             *//*                                                                         *//*    User-selectable configuration macros (specification only).           *//*                                                                         *//*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 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 ****/  /****                                                                 ****/  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/  /*                                                                       */  /* Uncomment the line below if you want to activate sub-pixel rendering  */  /* (a.k.a. LCD rendering, or ClearType) in this build of the library.    */  /*                                                                       */  /* Note that this feature is covered by several Microsoft patents        */  /* and should not be activated in any default build of the library.      */  /*                                                                       */  /* This macro has no impact on the FreeType API, only on its             */  /* _implementation_.  For example, using FT_RENDER_MODE_LCD when calling */  /* FT_Render_Glyph still generates a bitmap that is 3 times larger than  */  /* the original size; the difference will be that each triplet of        */  /* subpixels has R=G=B.                                                  */  /*                                                                       */  /* This is done to allow FreeType clients to run unmodified, forcing     */  /* them to display normal gray-level anti-aliased glyphs.                */  /*                                                                       */#define FT_CONFIG_OPTION_SUBPIXEL_RENDERING  /*************************************************************************/  /*                                                                       */  /* 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 integers is normally disabled when */  /* the __STDC__ macro is defined.  You can however disable this by       */  /* defining the macro FT_CONFIG_OPTION_FORCE_INT64 here.                 */  /*                                                                       */  /* 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 the            */  /*         `configure' script on supported platforms.                    */  /*                                                                       */#undef  FT_CONFIG_OPTION_FORCE_INT64  /*************************************************************************/  /*                                                                       */  /* LZW-compressed file support.                                          */  /*                                                                       */  /*   FreeType now handles font files that have been compressed with the  */  /*   `compress' program.  This is mostly used to parse many of the PCF   */  /*   files that come with various X11 distributions.  The implementation */  /*   uses NetBSD's `zopen' to partially uncompress the file on the fly   */  /*   (see src/lzw/ftgzip.c).                                             */  /*                                                                       */  /*   Define this macro if you want to enable this `feature'.             */  /*                                                                       */#define FT_CONFIG_OPTION_USE_LZW  /*************************************************************************/  /*                                                                       */  /* Gzip-compressed file support.                                         */  /*                                                                       */  /*   FreeType now handles font files that have been compressed with the  */  /*   `gzip' program.  This is mostly used to parse many of the PCF files */  /*   that come with XFree86.  The implementation uses `zlib' to          */  /*   partially uncompress the file on the fly (see src/gzip/ftgzip.c).   */  /*                                                                       */  /*   Define this macro if you want to enable this `feature'.  See also   */  /*   the macro FT_CONFIG_OPTION_SYSTEM_ZLIB below.                       */  /*                                                                       */#define FT_CONFIG_OPTION_USE_ZLIB  /*************************************************************************/  /*                                                                       */  /* ZLib library selection                                                */  /*                                                                       */  /*   This macro is only used when FT_CONFIG_OPTION_USE_ZLIB is defined.  */  /*   It allows FreeType's `ftgzip' component to link to the system's     */  /*   installation of the ZLib library.  This is useful on systems like   */  /*   Unix or VMS where it generally is already available.                */  /*                                                                       */  /*   If you let it undefined, the component will use its own copy        */  /*   of the zlib sources instead.  These have been modified to be        */  /*   included directly within the component and *not* export external    */  /*   function names.  This allows you to link any program with FreeType  */  /*   _and_ ZLib without linking conflicts.                               */  /*                                                                       */  /*   Do not #undef this macro here since the build system might define   */  /*   it for certain configurations only.                                 */  /*                                                                       *//* #define  FT_CONFIG_OPTION_SYSTEM_ZLIB */  /*************************************************************************/  /*                                                                       */  /* 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.                                           */  /*                                                                       */  /*   Do not #undef these macros here since the build system might define */  /*   them for certain configurations only.                               */  /*                                                                       *//* #define  FT_EXPORT(x)       extern x *//* #define  FT_EXPORT_DEF(x)   x */#ifndef __GNUC__# define __DLL_IMPORT__  __declspec(dllimport)# define __DLL_EXPORT__  __declspec(dllexport)#else# define __DLL_IMPORT__  __attribute__((dllimport)) extern# define __DLL_EXPORT__  __attribute__((dllexport)) extern#endif #if (defined __WIN32__) || (defined _WIN32)# ifdef BUILD_FREETYPE2_DLL#  define FREETYPE2_DLL_IMPEXP     __DLL_EXPORT__# elif defined(FREETYPE2_STATIC)#  define FREETYPE2_DLL_IMPEXP      # elif defined (USE_FREETYPE2_DLL)#  define FREETYPE2_DLL_IMPEXP     __DLL_IMPORT__# elif defined (USE_FREETYPE2_STATIC)#  define FREETYPE2_DLL_IMPEXP      # else /* assume USE_FREETYPE2_DLL */#  define FREETYPE2_DLL_IMPEXP     __DLL_IMPORT__# endif#else /* __WIN32__ */# define FREETYPE2_DLL_IMPEXP  #endif