misc/libfreetype/src/base/ftinit.c
changeset 9372 915436ff64ab
parent 9371 f3840de881bd
child 9373 b769a8e38cbd
equal deleted inserted replaced
9371:f3840de881bd 9372:915436ff64ab
     1 /***************************************************************************/
       
     2 /*                                                                         */
       
     3 /*  ftinit.c                                                               */
       
     4 /*                                                                         */
       
     5 /*    FreeType initialization layer (body).                                */
       
     6 /*                                                                         */
       
     7 /*  Copyright 1996-2001, 2002, 2005, 2007, 2009 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   /*************************************************************************/
       
    19   /*                                                                       */
       
    20   /*  The purpose of this file is to implement the following two           */
       
    21   /*  functions:                                                           */
       
    22   /*                                                                       */
       
    23   /*  FT_Add_Default_Modules():                                            */
       
    24   /*     This function is used to add the set of default modules to a      */
       
    25   /*     fresh new library object.  The set is taken from the header file  */
       
    26   /*     `freetype/config/ftmodule.h'.  See the document `FreeType 2.0     */
       
    27   /*     Build System' for more information.                               */
       
    28   /*                                                                       */
       
    29   /*  FT_Init_FreeType():                                                  */
       
    30   /*     This function creates a system object for the current platform,   */
       
    31   /*     builds a library out of it, then calls FT_Default_Drivers().      */
       
    32   /*                                                                       */
       
    33   /*  Note that even if FT_Init_FreeType() uses the implementation of the  */
       
    34   /*  system object defined at build time, client applications are still   */
       
    35   /*  able to provide their own `ftsystem.c'.                              */
       
    36   /*                                                                       */
       
    37   /*************************************************************************/
       
    38 
       
    39 
       
    40 #include <ft2build.h>
       
    41 #include FT_CONFIG_CONFIG_H
       
    42 #include FT_INTERNAL_OBJECTS_H
       
    43 #include FT_INTERNAL_DEBUG_H
       
    44 #include FT_MODULE_H
       
    45 #include "basepic.h"
       
    46 
       
    47 
       
    48   /*************************************************************************/
       
    49   /*                                                                       */
       
    50   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
       
    51   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
       
    52   /* messages during execution.                                            */
       
    53   /*                                                                       */
       
    54 #undef  FT_COMPONENT
       
    55 #define FT_COMPONENT  trace_init
       
    56 
       
    57 #ifndef FT_CONFIG_OPTION_PIC
       
    58 
       
    59 #undef  FT_USE_MODULE
       
    60 #ifdef __cplusplus
       
    61 #define FT_USE_MODULE( type, x )  extern "C" const type  x;
       
    62 #else
       
    63 #define FT_USE_MODULE( type, x )  extern const type  x;
       
    64 #endif
       
    65 
       
    66 
       
    67 #include FT_CONFIG_MODULES_H
       
    68 
       
    69 
       
    70 #undef  FT_USE_MODULE
       
    71 #define FT_USE_MODULE( type, x )  (const FT_Module_Class*)&(x),
       
    72 
       
    73   static
       
    74   const FT_Module_Class*  const ft_default_modules[] =
       
    75   {
       
    76 #include FT_CONFIG_MODULES_H
       
    77     0
       
    78   };
       
    79 
       
    80 #else /* FT_CONFIG_OPTION_PIC */
       
    81 
       
    82 #ifdef __cplusplus
       
    83 #define FT_EXTERNC  extern "C"
       
    84 #else
       
    85 #define FT_EXTERNC  extern
       
    86 #endif
       
    87 
       
    88   /* declare the module's class creation/destruction functions */
       
    89 #undef  FT_USE_MODULE
       
    90 #define FT_USE_MODULE( type, x )  \
       
    91   FT_EXTERNC FT_Error FT_Create_Class_##x( FT_Library library, FT_Module_Class** output_class ); \
       
    92   FT_EXTERNC void     FT_Destroy_Class_##x( FT_Library library, FT_Module_Class*  clazz );
       
    93 
       
    94 #include FT_CONFIG_MODULES_H
       
    95 
       
    96 
       
    97   /* count all module classes */
       
    98 #undef  FT_USE_MODULE
       
    99 #define FT_USE_MODULE( type, x )  MODULE_CLASS_##x,
       
   100 
       
   101   enum
       
   102   {
       
   103 #include FT_CONFIG_MODULES_H
       
   104     FT_NUM_MODULE_CLASSES
       
   105   };
       
   106 
       
   107   /* destroy all module classes */  
       
   108 #undef  FT_USE_MODULE
       
   109 #define FT_USE_MODULE( type, x )  \
       
   110   if ( classes[i] ) { FT_Destroy_Class_##x(library, classes[i]); } \
       
   111   i++;                                                             \
       
   112 
       
   113   FT_BASE_DEF( void )
       
   114   ft_destroy_default_module_classes( FT_Library  library )
       
   115   {
       
   116     FT_Module_Class** classes;
       
   117     FT_Memory         memory;
       
   118     FT_UInt           i;
       
   119     BasePIC*          pic_container = (BasePIC*)library->pic_container.base;
       
   120 
       
   121     if ( !pic_container->default_module_classes )
       
   122       return;
       
   123 
       
   124     memory = library->memory;
       
   125     classes = pic_container->default_module_classes;
       
   126     i = 0;
       
   127 
       
   128 #include FT_CONFIG_MODULES_H
       
   129 
       
   130     FT_FREE( classes );
       
   131     pic_container->default_module_classes = 0;
       
   132   }
       
   133 
       
   134   /* initialize all module classes and the pointer table */
       
   135 #undef  FT_USE_MODULE
       
   136 #define FT_USE_MODULE( type, x )                \
       
   137   error = FT_Create_Class_##x(library, &clazz); \
       
   138   if (error) goto Exit;                         \
       
   139   classes[i++] = clazz;
       
   140 
       
   141   FT_BASE_DEF( FT_Error )
       
   142   ft_create_default_module_classes( FT_Library  library )
       
   143   {
       
   144     FT_Error          error;
       
   145     FT_Memory         memory;
       
   146     FT_Module_Class** classes;
       
   147     FT_Module_Class*  clazz;
       
   148     FT_UInt           i;
       
   149     BasePIC*          pic_container = (BasePIC*)library->pic_container.base;
       
   150 
       
   151     memory = library->memory;  
       
   152     pic_container->default_module_classes = 0;
       
   153 
       
   154     if ( FT_ALLOC(classes, sizeof(FT_Module_Class*) * (FT_NUM_MODULE_CLASSES + 1) ) )
       
   155       return error;
       
   156     /* initialize all pointers to 0, especially the last one */
       
   157     for (i = 0; i < FT_NUM_MODULE_CLASSES; i++)
       
   158       classes[i] = 0;
       
   159     classes[FT_NUM_MODULE_CLASSES] = 0;
       
   160 
       
   161     i = 0;
       
   162 
       
   163 #include FT_CONFIG_MODULES_H
       
   164 
       
   165 Exit:    
       
   166     if (error) ft_destroy_default_module_classes( library );
       
   167     else pic_container->default_module_classes = classes;
       
   168 
       
   169     return error;    
       
   170   }
       
   171 
       
   172 
       
   173 #endif /* FT_CONFIG_OPTION_PIC */
       
   174 
       
   175   /* documentation is in ftmodapi.h */
       
   176 
       
   177   FT_EXPORT_DEF( void )
       
   178   FT_Add_Default_Modules( FT_Library  library )
       
   179   {
       
   180     FT_Error                       error;
       
   181     const FT_Module_Class* const*  cur;
       
   182 
       
   183 
       
   184     /* test for valid `library' delayed to FT_Add_Module() */
       
   185 
       
   186     cur = FT_DEFAULT_MODULES_GET;
       
   187     while ( *cur )
       
   188     {
       
   189       error = FT_Add_Module( library, *cur );
       
   190       /* notify errors, but don't stop */
       
   191       if ( error )
       
   192         FT_TRACE0(( "FT_Add_Default_Module:"
       
   193                     " Cannot install `%s', error = 0x%x\n",
       
   194                     (*cur)->module_name, error ));
       
   195       cur++;
       
   196     }
       
   197   }
       
   198 
       
   199 
       
   200   /* documentation is in freetype.h */
       
   201 
       
   202   FT_EXPORT_DEF( FT_Error )
       
   203   FT_Init_FreeType( FT_Library  *alibrary )
       
   204   {
       
   205     FT_Error   error;
       
   206     FT_Memory  memory;
       
   207 
       
   208 
       
   209     /* First of all, allocate a new system object -- this function is part */
       
   210     /* of the system-specific component, i.e. `ftsystem.c'.                */
       
   211 
       
   212     memory = FT_New_Memory();
       
   213     if ( !memory )
       
   214     {
       
   215       FT_ERROR(( "FT_Init_FreeType: cannot find memory manager\n" ));
       
   216       return FT_Err_Unimplemented_Feature;
       
   217     }
       
   218 
       
   219     /* build a library out of it, then fill it with the set of */
       
   220     /* default drivers.                                        */
       
   221 
       
   222     error = FT_New_Library( memory, alibrary );
       
   223     if ( error )
       
   224       FT_Done_Memory( memory );
       
   225     else
       
   226       FT_Add_Default_Modules( *alibrary );
       
   227 
       
   228     return error;
       
   229   }
       
   230 
       
   231 
       
   232   /* documentation is in freetype.h */
       
   233 
       
   234   FT_EXPORT_DEF( FT_Error )
       
   235   FT_Done_FreeType( FT_Library  library )
       
   236   {
       
   237     if ( library )
       
   238     {
       
   239       FT_Memory  memory = library->memory;
       
   240 
       
   241 
       
   242       /* Discard the library object */
       
   243       FT_Done_Library( library );
       
   244 
       
   245       /* discard memory manager */
       
   246       FT_Done_Memory( memory );
       
   247     }
       
   248 
       
   249     return FT_Err_Ok;
       
   250   }
       
   251 
       
   252 
       
   253 /* END */