/*************************************************************************/  /*                                                                       */  /* 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  /*************************************************************************/  /*                                                                       */  /* Support for Mac fonts                                                 */  /*                                                                       */  /*   Define this macro if you want support for outline fonts in Mac      */  /*   format (mac dfont, mac resource, macbinary containing a mac         */  /*   resource) on non-Mac platforms.                                     */  /*                                                                       */  /*   Note that the `FOND' resource isn't checked.                        */  /*                                                                       */#define FT_CONFIG_OPTION_MAC_FONTS  /*************************************************************************/  /*                                                                       */  /* Guessing methods to access embedded resource forks                    */  /*                                                                       */  /*   Enable extra Mac fonts support on non-Mac platforms (e.g.           */  /*   GNU/Linux).                                                         */  /*                                                                       */  /*   Resource forks which include fonts data are stored sometimes in     */  /*   locations which users or developers don't expected.  In some cases, */  /*   resource forks start with some offset from the head of a file.  In  */  /*   other cases, the actual resource fork is stored in file different   */  /*   from what the user specifies.  If this option is activated,         */  /*   FreeType tries to guess whether such offsets or different file      */  /*   names must be used.                                                 */  /*                                                                       */  /*   Note that normal, direct access of resource forks is controlled via */  /*   the FT_CONFIG_OPTION_MAC_FONTS option.                              */  /*                                                                       */#ifdef FT_CONFIG_OPTION_MAC_FONTS#define FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK#endif  /*************************************************************************/  /*                                                                       */  /* Allow the use of FT_Incremental_Interface to load typefaces that      */  /* contain no glyph data, but supply it via a callback function.         */  /* This allows FreeType to be used with the PostScript language, using   */  /* the GhostScript interpreter.                                          */  /*                                                                       *//* #define FT_CONFIG_OPTION_INCREMENTAL */  /*************************************************************************/  /*                                                                       */  /* The size in bytes of the render pool used by the scan-line converter  */  /* to do all of its work.                                                */  /*                                                                       */  /* This must be greater than 4KByte.                                     */  /*                                                                       */#define FT_RENDER_POOL_SIZE  16384L  /*************************************************************************/  /*                                                                       */  /* FT_MAX_MODULES                                                        */  /*                                                                       */  /*   The maximum number of modules that can be registered in a single    */  /*   FreeType library object.  32 is the default.                        */  /*                                                                       */#define FT_MAX_MODULES  32  /*************************************************************************/  /*                                                                       */  /* 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!      */  /*                                                                       */  /*   Do not #undef these macros here since the build system might define */  /*   them for certain configurations only.                               */  /*                                                                       *//* #define FT_DEBUG_LEVEL_ERROR *//* #define FT_DEBUG_LEVEL_TRACE */  /*************************************************************************/  /*                                                                       */  /* Memory Debugging                                                      */  /*                                                                       */  /*   FreeType now comes with an integrated memory debugger that is       */  /*   capable of detecting simple errors like memory leaks or double      */  /*   deletes.  To compile it within your build of the library, you       */  /*   should define FT_DEBUG_MEMORY here.                                 */  /*                                                                       */  /*   Note that the memory debugger is only activated at runtime when     */  /*   when the _environment_ variable "FT2_DEBUG_MEMORY" is defined also! */  /*                                                                       */  /*   Do not #undef this macro here since the build system might define   */  /*   it for certain configurations only.                                 */  /*                                                                       *//* #define FT_DEBUG_MEMORY */  /*************************************************************************/  /*                                                                       */  /* 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  /*************************************************************************/  /*************************************************************************/  /****                                                                 ****/  /****        S F N T   D R I V E R    C O N F I G U R A T I O N       ****/  /****                                                                 ****/  /*************************************************************************/  /*************************************************************************/  /*************************************************************************/  /*                                                                       */  /* Define TT_CONFIG_OPTION_EMBEDDED_BITMAPS if you want to support       */  /* embedded bitmaps in all formats using the SFNT module (namely         */  /* TrueType & OpenType).                                                 */  /*                                                                       */#define TT_CONFIG_OPTION_EMBEDDED_BITMAPS  /*************************************************************************/  /*                                                                       */  /* Define TT_CONFIG_OPTION_POSTSCRIPT_NAMES if you want to be able to    */  /* load and enumerate the glyph Postscript names in a TrueType or        */