ftoption.h

Trolltech公司发布的基于C++图形开发环境

/***************************************************************************/
/*                                                                         */
/*  ftoption.h                                                             */
/*                                                                         */
/*    User-selectable configuration macros (specification only).           */
/*                                                                         */
/*  Copyright 1996-2000 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__


#ifdef __cplusplus
  extern "C" {
#endif


  /*************************************************************************/
  /*                                                                       */
  /*                 USER-SELECTABLE CONFIGURATION MACROS                  */
  /*                                                                       */
  /* These macros can be toggled by developers to enable or disable        */
  /* certain aspects of FreeType.  This is a default file, where all major */
  /* options are enabled.                                                  */
  /*                                                                       */
  /* Note that if some modifications are required for your build, we       */
  /* advise you to put a modified copy of this file in your build          */
  /* directory, rather than modifying it in-place.                         */
  /*                                                                       */
  /* The build directory is normally `freetype/builds/<system>' and        */
  /* contains build or system-specific files that are included in          */
  /* priority when building the library.                                   */
  /*                                                                       */
  /*************************************************************************/


  /*************************************************************************/
  /*************************************************************************/
  /****                                                                 ****/
  /**** 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


  /*************************************************************************/
  /*                                                                       */
  /* 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 */
  /*   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 the non-ANSI `long long' 64-bit type.  You can */
  /* activate it by defining the FTCALC_USE_LONG_LONG macro.  Note that    */
  /* this will produce many -ansi warnings during library compilation, and */
  /* that in many cases the generated code will not be smaller or faster!  */
  /*                                                                       */
#undef FTCALC_USE_LONG_LONG


  /*************************************************************************/
  /*                                                                       */
  /* 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.                                           */
  /*                                                                       */
#undef FT_EXPORT
#undef FT_EXPORT_DEF


  /*************************************************************************/
  /*                                                                       */
  /* Debug level                                                           */
  /*                                                                       */
  /*   FreeType can be compiled in debug or trace mode.  In debug mode,    */
  /*   errors are reported through the `ftdebug' component.  In trace      */
  /*   mode, additional messages are sent to the standard output during    */
  /*   execution.                                                          */
  /*                                                                       */
  /*   Define FT_DEBUG_LEVEL_ERROR to build the library in debug mode.     */
  /*   Define FT_DEBUG_LEVEL_TRACE to build it in trace mode.              */
  /*                                                                       */
  /*   Don't define any of these macros to compile in `release' mode!      */
  /*                                                                       */