ROOT_528-00b_version: graf2d/freetype/src/freetype-2.3.12/include/freetype/internal/ftserv.h Source File

00001 /***************************************************************************/
00002 /*                                                                         */
00003 /*  ftserv.h                                                               */
00004 /*                                                                         */
00005 /*    The FreeType services (specification only).                          */
00006 /*                                                                         */
00007 /*  Copyright 2003, 2004, 2005, 2006, 2007 by                              */
00008 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
00009 /*                                                                         */
00010 /*  This file is part of the FreeType project, and may only be used,       */
00011 /*  modified, and distributed under the terms of the FreeType project      */
00012 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
00013 /*  this file you indicate that you have read the license and              */
00014 /*  understand and accept it fully.                                        */
00015 /*                                                                         */
00016 /***************************************************************************/
00017 
00018   /*************************************************************************/
00019   /*                                                                       */
00020   /*  Each module can export one or more `services'.  Each service is      */
00021   /*  identified by a constant string and modeled by a pointer; the latter */
00022   /*  generally corresponds to a structure containing function pointers.   */
00023   /*                                                                       */
00024   /*  Note that a service's data cannot be a mere function pointer because */
00025   /*  in C it is possible that function pointers might be implemented      */
00026   /*  differently than data pointers (e.g. 48 bits instead of 32).         */
00027   /*                                                                       */
00028   /*************************************************************************/
00029 
00030 
00031 #ifndef __FTSERV_H__
00032 #define __FTSERV_H__
00033 
00034 
00035 FT_BEGIN_HEADER
00036 
00037 #if defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
00038 
00039   /* we disable the warning `conditional expression is constant' here */
00040   /* in order to compile cleanly with the maximum level of warnings   */
00041 #pragma warning( disable : 4127 )
00042 
00043 #endif /* _MSC_VER */
00044 
00045   /*
00046    * @macro:
00047    *   FT_FACE_FIND_SERVICE
00048    *
00049    * @description:
00050    *   This macro is used to look up a service from a face's driver module.
00051    *
00052    * @input:
00053    *   face ::
00054    *     The source face handle.
00055    *
00056    *   id ::
00057    *     A string describing the service as defined in the service's
00058    *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
00059    *     `multi-masters').  It is automatically prefixed with
00060    *     `FT_SERVICE_ID_'.
00061    *
00062    * @output:
00063    *   ptr ::
00064    *     A variable that receives the service pointer.  Will be NULL
00065    *     if not found.
00066    */
00067 #ifdef __cplusplus
00068 
00069 #define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
00070   FT_BEGIN_STMNT                                                            \
00071     FT_Module    module = FT_MODULE( FT_FACE( face )->driver );             \
00072     FT_Pointer   _tmp_  = NULL;                                             \
00073     FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                              \
00074                                                                             \
00075                                                                             \
00076     if ( module->clazz->get_interface )                                     \
00077       _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
00078     *_pptr_ = _tmp_;                                                        \
00079   FT_END_STMNT
00080 
00081 #else /* !C++ */
00082 
00083 #define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
00084   FT_BEGIN_STMNT                                                            \
00085     FT_Module   module = FT_MODULE( FT_FACE( face )->driver );              \
00086     FT_Pointer  _tmp_  = NULL;                                              \
00087                                                                             \
00088     if ( module->clazz->get_interface )                                     \
00089       _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
00090     ptr = _tmp_;                                                            \
00091   FT_END_STMNT
00092 
00093 #endif /* !C++ */
00094 
00095   /*
00096    * @macro:
00097    *   FT_FACE_FIND_GLOBAL_SERVICE
00098    *
00099    * @description:
00100    *   This macro is used to look up a service from all modules.
00101    *
00102    * @input:
00103    *   face ::
00104    *     The source face handle.
00105    *
00106    *   id ::
00107    *     A string describing the service as defined in the service's
00108    *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
00109    *     `multi-masters').  It is automatically prefixed with
00110    *     `FT_SERVICE_ID_'.
00111    *
00112    * @output:
00113    *   ptr ::
00114    *     A variable that receives the service pointer.  Will be NULL
00115    *     if not found.
00116    */
00117 #ifdef __cplusplus
00118 
00119 #define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
00120   FT_BEGIN_STMNT                                                   \
00121     FT_Module    module = FT_MODULE( FT_FACE( face )->driver );    \
00122     FT_Pointer   _tmp_;                                            \
00123     FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                     \
00124                                                                    \
00125                                                                    \
00126     _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
00127     *_pptr_ = _tmp_;                                               \
00128   FT_END_STMNT
00129 
00130 #else /* !C++ */
00131 
00132 #define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
00133   FT_BEGIN_STMNT                                                   \
00134     FT_Module   module = FT_MODULE( FT_FACE( face )->driver );     \
00135     FT_Pointer  _tmp_;                                             \
00136                                                                    \
00137                                                                    \
00138     _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
00139     ptr   = _tmp_;                                                 \
00140   FT_END_STMNT
00141 
00142 #endif /* !C++ */
00143 
00144 
00145   /*************************************************************************/
00146   /*************************************************************************/
00147   /*****                                                               *****/
00148   /*****         S E R V I C E   D E S C R I P T O R S                 *****/
00149   /*****                                                               *****/
00150   /*************************************************************************/
00151   /*************************************************************************/
00152 
00153   /*
00154    *  The following structure is used to _describe_ a given service
00155    *  to the library.  This is useful to build simple static service lists.
00156    */
00157   typedef struct  FT_ServiceDescRec_
00158   {
00159     const char*  serv_id;     /* service name         */
00160     const void*  serv_data;   /* service pointer/data */
00161 
00162   } FT_ServiceDescRec;
00163 
00164   typedef const FT_ServiceDescRec*  FT_ServiceDesc;
00165 
00166   /*************************************************************************/
00167   /*                                                                       */
00168   /* <Macro>                                                               */
00169   /*    FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6             */
00170   /*                                                                       */
00171   /* <Description>                                                         */
00172   /*    Used to initialize an array of FT_ServiceDescRec structs.          */
00173   /*                                                                       */
00174   /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
00175   /*    to called with a pointer where the allocated array is returned.    */
00176   /*    And when it is no longer needed a Destroy function needs           */
00177   /*    to be called to release that allocation.                           */
00178   /*                                                                       */
00179   /*    These functions should be manyally called from the pic_init and    */
00180   /*    pic_free functions of your module (see FT_DEFINE_MODULE)           */
00181   /*                                                                       */
00182   /*    When FT_CONFIG_OPTION_PIC is not defined the array will be         */
00183   /*    allocated in the global scope (or the scope where the macro        */
00184   /*    is used).                                                          */
00185   /*                                                                       */
00186 #ifndef FT_CONFIG_OPTION_PIC
00187 
00188 #define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
00189   static const FT_ServiceDescRec class_[] =                                  \
00190   {                                                                          \
00191   {serv_id_1, serv_data_1},                                                  \
00192   {NULL, NULL}                                                               \
00193   };
00194 #define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
00195         serv_id_2, serv_data_2)                                              \
00196   static const FT_ServiceDescRec class_[] =                                  \
00197   {                                                                          \
00198   {serv_id_1, serv_data_1},                                                  \
00199   {serv_id_2, serv_data_2},                                                  \
00200   {NULL, NULL}                                                               \
00201   };
00202 #define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
00203         serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
00204   static const FT_ServiceDescRec class_[] =                                  \
00205   {                                                                          \
00206   {serv_id_1, serv_data_1},                                                  \
00207   {serv_id_2, serv_data_2},                                                  \
00208   {serv_id_3, serv_data_3},                                                  \
00209   {NULL, NULL}                                                               \
00210   };
00211 #define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
00212         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
00213         serv_id_4, serv_data_4)                                              \
00214   static const FT_ServiceDescRec class_[] =                                  \
00215   {                                                                          \
00216   {serv_id_1, serv_data_1},                                                  \
00217   {serv_id_2, serv_data_2},                                                  \
00218   {serv_id_3, serv_data_3},                                                  \
00219   {serv_id_4, serv_data_4},                                                  \
00220   {NULL, NULL}                                                               \
00221   };
00222 #define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
00223         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
00224         serv_id_4, serv_data_4, serv_id_5, serv_data_5)                      \
00225   static const FT_ServiceDescRec class_[] =                                  \
00226   {                                                                          \
00227   {serv_id_1, serv_data_1},                                                  \
00228   {serv_id_2, serv_data_2},                                                  \
00229   {serv_id_3, serv_data_3},                                                  \
00230   {serv_id_4, serv_data_4},                                                  \
00231   {serv_id_5, serv_data_5},                                                  \
00232   {NULL, NULL}                                                               \
00233   };
00234 #define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
00235         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
00236         serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
00237         serv_id_6, serv_data_6)                                              \
00238   static const FT_ServiceDescRec class_[] =                                  \
00239   {                                                                          \
00240   {serv_id_1, serv_data_1},                                                  \
00241   {serv_id_2, serv_data_2},                                                  \
00242   {serv_id_3, serv_data_3},                                                  \
00243   {serv_id_4, serv_data_4},                                                  \
00244   {serv_id_5, serv_data_5},                                                  \
00245   {serv_id_6, serv_data_6},                                                  \
00246   {NULL, NULL}                                                               \
00247   };
00248 
00249 #else /* FT_CONFIG_OPTION_PIC */ 
00250 
00251 #define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
00252   void                                                                       \
00253   FT_Destroy_Class_##class_( FT_Library library,                             \
00254                              FT_ServiceDescRec* clazz )                      \
00255   {                                                                          \
00256     FT_Memory memory = library->memory;                                      \
00257     if ( clazz )                                                             \
00258       FT_FREE( clazz );                                                      \
00259   }                                                                          \
00260                                                                              \
00261   FT_Error                                                                   \
00262   FT_Create_Class_##class_( FT_Library library,                              \
00263                             FT_ServiceDescRec** output_class)                \
00264   {                                                                          \
00265     FT_ServiceDescRec*  clazz;                                               \
00266     FT_Error          error;                                                 \
00267     FT_Memory memory = library->memory;                                      \
00268                                                                              \
00269     if ( FT_ALLOC( clazz, sizeof(*clazz)*2 ) )                               \
00270       return error;                                                          \
00271     clazz[0].serv_id = serv_id_1;                                            \
00272     clazz[0].serv_data = serv_data_1;                                        \
00273     clazz[1].serv_id = NULL;                                                 \
00274     clazz[1].serv_data = NULL;                                               \
00275     *output_class = clazz;                                                   \
00276     return FT_Err_Ok;                                                        \
00277   } 
00278 
00279 #define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
00280         serv_id_2, serv_data_2)                                              \
00281   void                                                                       \
00282   FT_Destroy_Class_##class_( FT_Library library,                             \
00283                              FT_ServiceDescRec* clazz )                      \
00284   {                                                                          \
00285     FT_Memory memory = library->memory;                                      \
00286     if ( clazz )                                                             \
00287       FT_FREE( clazz );                                                      \
00288   }                                                                          \
00289                                                                              \
00290   FT_Error                                                                   \
00291   FT_Create_Class_##class_( FT_Library library,                              \
00292                             FT_ServiceDescRec** output_class)                \
00293   {                                                                          \
00294     FT_ServiceDescRec*  clazz;                                               \
00295     FT_Error          error;                                                 \
00296     FT_Memory memory = library->memory;                                      \
00297                                                                              \
00298     if ( FT_ALLOC( clazz, sizeof(*clazz)*3 ) )                               \
00299       return error;                                                          \
00300     clazz[0].serv_id = serv_id_1;                                            \
00301     clazz[0].serv_data = serv_data_1;                                        \
00302     clazz[1].serv_id = serv_id_2;                                            \
00303     clazz[1].serv_data = serv_data_2;                                        \
00304     clazz[2].serv_id = NULL;                                                 \
00305     clazz[2].serv_data = NULL;                                               \
00306     *output_class = clazz;                                                   \
00307     return FT_Err_Ok;                                                        \
00308   } 
00309 
00310 #define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
00311         serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
00312   void                                                                       \
00313   FT_Destroy_Class_##class_( FT_Library library,                             \
00314                              FT_ServiceDescRec* clazz )                      \
00315   {                                                                          \
00316     FT_Memory memory = library->memory;                                      \
00317     if ( clazz )                                                             \
00318       FT_FREE( clazz );                                                      \
00319   }                                                                          \
00320                                                                              \
00321   FT_Error                                                                   \
00322   FT_Create_Class_##class_( FT_Library library,                              \
00323                             FT_ServiceDescRec** output_class)                \
00324   {                                                                          \
00325     FT_ServiceDescRec*  clazz;                                               \
00326     FT_Error          error;                                                 \
00327     FT_Memory memory = library->memory;                                      \
00328                                                                              \
00329     if ( FT_ALLOC( clazz, sizeof(*clazz)*4 ) )                               \
00330       return error;                                                          \
00331     clazz[0].serv_id = serv_id_1;                                            \
00332     clazz[0].serv_data = serv_data_1;                                        \
00333     clazz[1].serv_id = serv_id_2;                                            \
00334     clazz[1].serv_data = serv_data_2;                                        \
00335     clazz[2].serv_id = serv_id_3;                                            \
00336     clazz[2].serv_data = serv_data_3;                                        \
00337     clazz[3].serv_id = NULL;                                                 \
00338     clazz[3].serv_data = NULL;                                               \
00339     *output_class = clazz;                                                   \
00340     return FT_Err_Ok;                                                        \
00341   } 
00342 
00343 #define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
00344         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
00345         serv_id_4, serv_data_4)                                              \
00346   void                                                                       \
00347   FT_Destroy_Class_##class_( FT_Library library,                             \
00348                              FT_ServiceDescRec* clazz )                      \
00349   {                                                                          \
00350     FT_Memory memory = library->memory;                                      \
00351     if ( clazz )                                                             \
00352       FT_FREE( clazz );                                                      \
00353   }                                                                          \
00354                                                                              \
00355   FT_Error                                                                   \
00356   FT_Create_Class_##class_( FT_Library library,                              \
00357                             FT_ServiceDescRec** output_class)                \
00358   {                                                                          \
00359     FT_ServiceDescRec*  clazz;                                               \
00360     FT_Error          error;                                                 \
00361     FT_Memory memory = library->memory;                                      \
00362                                                                              \
00363     if ( FT_ALLOC( clazz, sizeof(*clazz)*5 ) )                               \
00364       return error;                                                          \
00365     clazz[0].serv_id = serv_id_1;                                            \
00366     clazz[0].serv_data = serv_data_1;                                        \
00367     clazz[1].serv_id = serv_id_2;                                            \
00368     clazz[1].serv_data = serv_data_2;                                        \
00369     clazz[2].serv_id = serv_id_3;                                            \
00370     clazz[2].serv_data = serv_data_3;                                        \
00371     clazz[3].serv_id = serv_id_4;                                            \
00372     clazz[3].serv_data = serv_data_4;                                        \
00373     clazz[4].serv_id = NULL;                                                 \
00374     clazz[4].serv_data = NULL;                                               \
00375     *output_class = clazz;                                                   \
00376     return FT_Err_Ok;                                                        \
00377   } 
00378 
00379 #define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
00380         serv_id_2, serv_data_2, serv_id_3, serv_data_3, serv_id_4,           \
00381         serv_data_4, serv_id_5, serv_data_5)                                 \
00382   void                                                                       \
00383   FT_Destroy_Class_##class_( FT_Library library,                             \
00384                              FT_ServiceDescRec* clazz )                      \
00385   {                                                                          \
00386     FT_Memory memory = library->memory;                                      \
00387     if ( clazz )                                                             \
00388       FT_FREE( clazz );                                                      \
00389   }                                                                          \
00390                                                                              \
00391   FT_Error                                                                   \
00392   FT_Create_Class_##class_( FT_Library library,                              \
00393                             FT_ServiceDescRec** output_class)                \
00394   {                                                                          \
00395     FT_ServiceDescRec*  clazz;                                               \
00396     FT_Error          error;                                                 \
00397     FT_Memory memory = library->memory;                                      \
00398                                                                              \
00399     if ( FT_ALLOC( clazz, sizeof(*clazz)*6 ) )                               \
00400       return error;                                                          \
00401     clazz[0].serv_id = serv_id_1;                                            \
00402     clazz[0].serv_data = serv_data_1;                                        \
00403     clazz[1].serv_id = serv_id_2;                                            \
00404     clazz[1].serv_data = serv_data_2;                                        \
00405     clazz[2].serv_id = serv_id_3;                                            \
00406     clazz[2].serv_data = serv_data_3;                                        \
00407     clazz[3].serv_id = serv_id_4;                                            \
00408     clazz[3].serv_data = serv_data_4;                                        \
00409     clazz[4].serv_id = serv_id_5;                                            \
00410     clazz[4].serv_data = serv_data_5;                                        \
00411     clazz[5].serv_id = NULL;                                                 \
00412     clazz[5].serv_data = NULL;                                               \
00413     *output_class = clazz;                                                   \
00414     return FT_Err_Ok;                                                        \
00415   } 
00416 
00417 #define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
00418         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
00419         serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
00420         serv_id_6, serv_data_6)                                              \
00421   void                                                                       \
00422   FT_Destroy_Class_##class_( FT_Library library,                             \
00423                              FT_ServiceDescRec* clazz )                      \
00424   {                                                                          \
00425     FT_Memory memory = library->memory;                                      \
00426     if ( clazz )                                                             \
00427       FT_FREE( clazz );                                                      \
00428   }                                                                          \
00429                                                                              \
00430   FT_Error                                                                   \
00431   FT_Create_Class_##class_( FT_Library library,                              \
00432                             FT_ServiceDescRec** output_class)                \
00433   {                                                                          \
00434     FT_ServiceDescRec*  clazz;                                               \
00435     FT_Error          error;                                                 \
00436     FT_Memory memory = library->memory;                                      \
00437                                                                              \
00438     if ( FT_ALLOC( clazz, sizeof(*clazz)*7 ) )                               \
00439       return error;                                                          \
00440     clazz[0].serv_id = serv_id_1;                                            \
00441     clazz[0].serv_data = serv_data_1;                                        \
00442     clazz[1].serv_id = serv_id_2;                                            \
00443     clazz[1].serv_data = serv_data_2;                                        \
00444     clazz[2].serv_id = serv_id_3;                                            \
00445     clazz[2].serv_data = serv_data_3;                                        \
00446     clazz[3].serv_id = serv_id_4;                                            \
00447     clazz[3].serv_data = serv_data_4;                                        \
00448     clazz[4].serv_id = serv_id_5;                                            \
00449     clazz[4].serv_data = serv_data_5;                                        \
00450     clazz[5].serv_id = serv_id_6;                                            \
00451     clazz[5].serv_data = serv_data_6;                                        \
00452     clazz[6].serv_id = NULL;                                                 \
00453     clazz[6].serv_data = NULL;                                               \
00454     *output_class = clazz;                                                   \
00455     return FT_Err_Ok;                                                        \
00456   } 
00457 #endif /* FT_CONFIG_OPTION_PIC */ 
00458 
00459   /*
00460    *  Parse a list of FT_ServiceDescRec descriptors and look for
00461    *  a specific service by ID.  Note that the last element in the
00462    *  array must be { NULL, NULL }, and that the function should
00463    *  return NULL if the service isn't available.
00464    *
00465    *  This function can be used by modules to implement their
00466    *  `get_service' method.
00467    */
00468   FT_BASE( FT_Pointer )
00469   ft_service_list_lookup( FT_ServiceDesc  service_descriptors,
00470                           const char*     service_id );
00471 
00472 
00473   /*************************************************************************/
00474   /*************************************************************************/
00475   /*****                                                               *****/
00476   /*****             S E R V I C E S   C A C H E                       *****/
00477   /*****                                                               *****/
00478   /*************************************************************************/
00479   /*************************************************************************/
00480 
00481   /*
00482    *  This structure is used to store a cache for several frequently used
00483    *  services.  It is the type of `face->internal->services'.  You
00484    *  should only use FT_FACE_LOOKUP_SERVICE to access it.
00485    *
00486    *  All fields should have the type FT_Pointer to relax compilation
00487    *  dependencies.  We assume the developer isn't completely stupid.
00488    *
00489    *  Each field must be named `service_XXXX' where `XXX' corresponds to
00490    *  the correct FT_SERVICE_ID_XXXX macro.  See the definition of
00491    *  FT_FACE_LOOKUP_SERVICE below how this is implemented.
00492    *
00493    */
00494   typedef struct  FT_ServiceCacheRec_
00495   {
00496     FT_Pointer  service_POSTSCRIPT_FONT_NAME;
00497     FT_Pointer  service_MULTI_MASTERS;
00498     FT_Pointer  service_GLYPH_DICT;
00499     FT_Pointer  service_PFR_METRICS;
00500     FT_Pointer  service_WINFNT;
00501 
00502   } FT_ServiceCacheRec, *FT_ServiceCache;
00503 
00504 
00505   /*
00506    *  A magic number used within the services cache.
00507    */
00508 #define FT_SERVICE_UNAVAILABLE  ((FT_Pointer)-2)  /* magic number */
00509 
00510 
00511   /*
00512    * @macro:
00513    *   FT_FACE_LOOKUP_SERVICE
00514    *
00515    * @description:
00516    *   This macro is used to lookup a service from a face's driver module
00517    *   using its cache.
00518    *
00519    * @input:
00520    *   face::
00521    *     The source face handle containing the cache.
00522    *
00523    *   field ::
00524    *     The field name in the cache.
00525    *
00526    *   id ::
00527    *     The service ID.
00528    *
00529    * @output:
00530    *   ptr ::
00531    *     A variable receiving the service data.  NULL if not available.
00532    */
00533 #ifdef __cplusplus
00534 
00535 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
00536   FT_BEGIN_STMNT                                               \
00537     FT_Pointer   svc;                                          \
00538     FT_Pointer*  Pptr = (FT_Pointer*)&(ptr);                   \
00539                                                                \
00540                                                                \
00541     svc = FT_FACE( face )->internal->services. service_ ## id; \
00542     if ( svc == FT_SERVICE_UNAVAILABLE )                       \
00543       svc = NULL;                                              \
00544     else if ( svc == NULL )                                    \
00545     {                                                          \
00546       FT_FACE_FIND_SERVICE( face, svc, id );                   \
00547                                                                \
00548       FT_FACE( face )->internal->services. service_ ## id =    \
00549         (FT_Pointer)( svc != NULL ? svc                        \
00550                                   : FT_SERVICE_UNAVAILABLE );  \
00551     }                                                          \
00552     *Pptr = svc;                                               \
00553   FT_END_STMNT
00554 
00555 #else /* !C++ */
00556 
00557 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
00558   FT_BEGIN_STMNT                                               \
00559     FT_Pointer  svc;                                           \
00560                                                                \
00561                                                                \
00562     svc = FT_FACE( face )->internal->services. service_ ## id; \
00563     if ( svc == FT_SERVICE_UNAVAILABLE )                       \
00564       svc = NULL;                                              \
00565     else if ( svc == NULL )                                    \
00566     {                                                          \
00567       FT_FACE_FIND_SERVICE( face, svc, id );                   \
00568                                                                \
00569       FT_FACE( face )->internal->services. service_ ## id =    \
00570         (FT_Pointer)( svc != NULL ? svc                        \
00571                                   : FT_SERVICE_UNAVAILABLE );  \
00572     }                                                          \
00573     ptr = svc;                                                 \
00574   FT_END_STMNT
00575 
00576 #endif /* !C++ */
00577 
00578   /*
00579    *  A macro used to define new service structure types.
00580    */
00581 
00582 #define FT_DEFINE_SERVICE( name )            \
00583   typedef struct FT_Service_ ## name ## Rec_ \
00584     FT_Service_ ## name ## Rec ;             \
00585   typedef struct FT_Service_ ## name ## Rec_ \
00586     const * FT_Service_ ## name ;            \
00587   struct FT_Service_ ## name ## Rec_
00588 
00589   /* */
00590 
00591   /*
00592    *  The header files containing the services.
00593    */
00594 
00595 #define FT_SERVICE_BDF_H                <freetype/internal/services/svbdf.h>
00596 #define FT_SERVICE_CID_H                <freetype/internal/services/svcid.h>
00597 #define FT_SERVICE_GLYPH_DICT_H         <freetype/internal/services/svgldict.h>
00598 #define FT_SERVICE_GX_VALIDATE_H        <freetype/internal/services/svgxval.h>
00599 #define FT_SERVICE_KERNING_H            <freetype/internal/services/svkern.h>
00600 #define FT_SERVICE_MULTIPLE_MASTERS_H   <freetype/internal/services/svmm.h>
00601 #define FT_SERVICE_OPENTYPE_VALIDATE_H  <freetype/internal/services/svotval.h>
00602 #define FT_SERVICE_PFR_H                <freetype/internal/services/svpfr.h>
00603 #define FT_SERVICE_POSTSCRIPT_CMAPS_H   <freetype/internal/services/svpscmap.h>
00604 #define FT_SERVICE_POSTSCRIPT_INFO_H    <freetype/internal/services/svpsinfo.h>
00605 #define FT_SERVICE_POSTSCRIPT_NAME_H    <freetype/internal/services/svpostnm.h>
00606 #define FT_SERVICE_SFNT_H               <freetype/internal/services/svsfnt.h>
00607 #define FT_SERVICE_TRUETYPE_ENGINE_H    <freetype/internal/services/svtteng.h>
00608 #define FT_SERVICE_TT_CMAP_H            <freetype/internal/services/svttcmap.h>
00609 #define FT_SERVICE_WINFNT_H             <freetype/internal/services/svwinfnt.h>
00610 #define FT_SERVICE_XFREE86_NAME_H       <freetype/internal/services/svxf86nm.h>
00611 #define FT_SERVICE_TRUETYPE_GLYF_H      <freetype/internal/services/svttglyf.h>
00612 
00613  /* */
00614 
00615 FT_END_HEADER
00616 
00617 #endif /* __FTSERV_H__ */
00618 
00619 
00620 /* END */