Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /***************************************************************************/
  2. /*                                                                         */
  3. /*  ftserv.h                                                               */
  4. /*                                                                         */
  5. /*    The FreeType services (specification only).                          */
  6. /*                                                                         */
  7. /*  Copyright 2003, 2004, 2005, 2006, 2007 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.   /*  Each module can export one or more `services'.  Each service is      */
  21.   /*  identified by a constant string and modeled by a pointer; the latter */
  22.   /*  generally corresponds to a structure containing function pointers.   */
  23.   /*                                                                       */
  24.   /*  Note that a service's data cannot be a mere function pointer because */
  25.   /*  in C it is possible that function pointers might be implemented      */
  26.   /*  differently than data pointers (e.g. 48 bits instead of 32).         */
  27.   /*                                                                       */
  28.   /*************************************************************************/
  29.  
  30.  
  31. #ifndef __FTSERV_H__
  32. #define __FTSERV_H__
  33.  
  34.  
  35. FT_BEGIN_HEADER
  36.  
  37. #if defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
  38.  
  39.   /* we disable the warning `conditional expression is constant' here */
  40.   /* in order to compile cleanly with the maximum level of warnings   */
  41. #pragma warning( disable : 4127 )
  42.  
  43. #endif /* _MSC_VER */
  44.  
  45.   /*
  46.    * @macro:
  47.    *   FT_FACE_FIND_SERVICE
  48.    *
  49.    * @description:
  50.    *   This macro is used to look up a service from a face's driver module.
  51.    *
  52.    * @input:
  53.    *   face ::
  54.    *     The source face handle.
  55.    *
  56.    *   id ::
  57.    *     A string describing the service as defined in the service's
  58.    *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
  59.    *     `multi-masters').  It is automatically prefixed with
  60.    *     `FT_SERVICE_ID_'.
  61.    *
  62.    * @output:
  63.    *   ptr ::
  64.    *     A variable that receives the service pointer.  Will be NULL
  65.    *     if not found.
  66.    */
  67. #ifdef __cplusplus
  68.  
  69. #define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
  70.   FT_BEGIN_STMNT                                                            \
  71.     FT_Module    module = FT_MODULE( FT_FACE( face )->driver );             \
  72.     FT_Pointer   _tmp_  = NULL;                                             \
  73.     FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                              \
  74.                                                                             \
  75.                                                                             \
  76.     if ( module->clazz->get_interface )                                     \
  77.       _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
  78.     *_pptr_ = _tmp_;                                                        \
  79.   FT_END_STMNT
  80.  
  81. #else /* !C++ */
  82.  
  83. #define FT_FACE_FIND_SERVICE( face, ptr, id )                               \
  84.   FT_BEGIN_STMNT                                                            \
  85.     FT_Module   module = FT_MODULE( FT_FACE( face )->driver );              \
  86.     FT_Pointer  _tmp_  = NULL;                                              \
  87.                                                                             \
  88.     if ( module->clazz->get_interface )                                     \
  89.       _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
  90.     ptr = _tmp_;                                                            \
  91.   FT_END_STMNT
  92.  
  93. #endif /* !C++ */
  94.  
  95.   /*
  96.    * @macro:
  97.    *   FT_FACE_FIND_GLOBAL_SERVICE
  98.    *
  99.    * @description:
  100.    *   This macro is used to look up a service from all modules.
  101.    *
  102.    * @input:
  103.    *   face ::
  104.    *     The source face handle.
  105.    *
  106.    *   id ::
  107.    *     A string describing the service as defined in the service's
  108.    *     header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
  109.    *     `multi-masters').  It is automatically prefixed with
  110.    *     `FT_SERVICE_ID_'.
  111.    *
  112.    * @output:
  113.    *   ptr ::
  114.    *     A variable that receives the service pointer.  Will be NULL
  115.    *     if not found.
  116.    */
  117. #ifdef __cplusplus
  118.  
  119. #define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
  120.   FT_BEGIN_STMNT                                                   \
  121.     FT_Module    module = FT_MODULE( FT_FACE( face )->driver );    \
  122.     FT_Pointer   _tmp_;                                            \
  123.     FT_Pointer*  _pptr_ = (FT_Pointer*)&(ptr);                     \
  124.                                                                    \
  125.                                                                    \
  126.     _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
  127.     *_pptr_ = _tmp_;                                               \
  128.   FT_END_STMNT
  129.  
  130. #else /* !C++ */
  131.  
  132. #define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id )               \
  133.   FT_BEGIN_STMNT                                                   \
  134.     FT_Module   module = FT_MODULE( FT_FACE( face )->driver );     \
  135.     FT_Pointer  _tmp_;                                             \
  136.                                                                    \
  137.                                                                    \
  138.     _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
  139.     ptr   = _tmp_;                                                 \
  140.   FT_END_STMNT
  141.  
  142. #endif /* !C++ */
  143.  
  144.  
  145.   /*************************************************************************/
  146.   /*************************************************************************/
  147.   /*****                                                               *****/
  148.   /*****         S E R V I C E   D E S C R I P T O R S                 *****/
  149.   /*****                                                               *****/
  150.   /*************************************************************************/
  151.   /*************************************************************************/
  152.  
  153.   /*
  154.    *  The following structure is used to _describe_ a given service
  155.    *  to the library.  This is useful to build simple static service lists.
  156.    */
  157.   typedef struct  FT_ServiceDescRec_
  158.   {
  159.     const char*  serv_id;     /* service name         */
  160.     const void*  serv_data;   /* service pointer/data */
  161.  
  162.   } FT_ServiceDescRec;
  163.  
  164.   typedef const FT_ServiceDescRec*  FT_ServiceDesc;
  165.  
  166.   /*************************************************************************/
  167.   /*                                                                       */
  168.   /* <Macro>                                                               */
  169.   /*    FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6             */
  170.   /*                                                                       */
  171.   /* <Description>                                                         */
  172.   /*    Used to initialize an array of FT_ServiceDescRec structs.          */
  173.   /*                                                                       */
  174.   /*    When FT_CONFIG_OPTION_PIC is defined a Create funtion will need    */
  175.   /*    to called with a pointer where the allocated array is returned.    */
  176.   /*    And when it is no longer needed a Destroy function needs           */
  177.   /*    to be called to release that allocation.                           */
  178.   /*                                                                       */
  179.   /*    These functions should be manyally called from the pic_init and    */
  180.   /*    pic_free functions of your module (see FT_DEFINE_MODULE)           */
  181.   /*                                                                       */
  182.   /*    When FT_CONFIG_OPTION_PIC is not defined the array will be         */
  183.   /*    allocated in the global scope (or the scope where the macro        */
  184.   /*    is used).                                                          */
  185.   /*                                                                       */
  186. #ifndef FT_CONFIG_OPTION_PIC
  187.  
  188. #define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
  189.   static const FT_ServiceDescRec class_[] =                                  \
  190.   {                                                                          \
  191.   {serv_id_1, serv_data_1},                                                  \
  192.   {NULL, NULL}                                                               \
  193.   };
  194. #define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
  195.         serv_id_2, serv_data_2)                                              \
  196.   static const FT_ServiceDescRec class_[] =                                  \
  197.   {                                                                          \
  198.   {serv_id_1, serv_data_1},                                                  \
  199.   {serv_id_2, serv_data_2},                                                  \
  200.   {NULL, NULL}                                                               \
  201.   };
  202. #define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
  203.         serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
  204.   static const FT_ServiceDescRec class_[] =                                  \
  205.   {                                                                          \
  206.   {serv_id_1, serv_data_1},                                                  \
  207.   {serv_id_2, serv_data_2},                                                  \
  208.   {serv_id_3, serv_data_3},                                                  \
  209.   {NULL, NULL}                                                               \
  210.   };
  211. #define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
  212.         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
  213.         serv_id_4, serv_data_4)                                              \
  214.   static const FT_ServiceDescRec class_[] =                                  \
  215.   {                                                                          \
  216.   {serv_id_1, serv_data_1},                                                  \
  217.   {serv_id_2, serv_data_2},                                                  \
  218.   {serv_id_3, serv_data_3},                                                  \
  219.   {serv_id_4, serv_data_4},                                                  \
  220.   {NULL, NULL}                                                               \
  221.   };
  222. #define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
  223.         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
  224.         serv_id_4, serv_data_4, serv_id_5, serv_data_5)                      \
  225.   static const FT_ServiceDescRec class_[] =                                  \
  226.   {                                                                          \
  227.   {serv_id_1, serv_data_1},                                                  \
  228.   {serv_id_2, serv_data_2},                                                  \
  229.   {serv_id_3, serv_data_3},                                                  \
  230.   {serv_id_4, serv_data_4},                                                  \
  231.   {serv_id_5, serv_data_5},                                                  \
  232.   {NULL, NULL}                                                               \
  233.   };
  234. #define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
  235.         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
  236.         serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
  237.         serv_id_6, serv_data_6)                                              \
  238.   static const FT_ServiceDescRec class_[] =                                  \
  239.   {                                                                          \
  240.   {serv_id_1, serv_data_1},                                                  \
  241.   {serv_id_2, serv_data_2},                                                  \
  242.   {serv_id_3, serv_data_3},                                                  \
  243.   {serv_id_4, serv_data_4},                                                  \
  244.   {serv_id_5, serv_data_5},                                                  \
  245.   {serv_id_6, serv_data_6},                                                  \
  246.   {NULL, NULL}                                                               \
  247.   };
  248.  
  249. #else /* FT_CONFIG_OPTION_PIC */
  250.  
  251. #define FT_DEFINE_SERVICEDESCREC1(class_, serv_id_1, serv_data_1)            \
  252.   void                                                                       \
  253.   FT_Destroy_Class_##class_( FT_Library library,                             \
  254.                              FT_ServiceDescRec* clazz )                      \
  255.   {                                                                          \
  256.     FT_Memory memory = library->memory;                                      \
  257.     if ( clazz )                                                             \
  258.       FT_FREE( clazz );                                                      \
  259.   }                                                                          \
  260.                                                                              \
  261.   FT_Error                                                                   \
  262.   FT_Create_Class_##class_( FT_Library library,                              \
  263.                             FT_ServiceDescRec** output_class)                \
  264.   {                                                                          \
  265.     FT_ServiceDescRec*  clazz;                                               \
  266.     FT_Error          error;                                                 \
  267.     FT_Memory memory = library->memory;                                      \
  268.                                                                              \
  269.     if ( FT_ALLOC( clazz, sizeof(*clazz)*2 ) )                               \
  270.       return error;                                                          \
  271.     clazz[0].serv_id = serv_id_1;                                            \
  272.     clazz[0].serv_data = serv_data_1;                                        \
  273.     clazz[1].serv_id = NULL;                                                 \
  274.     clazz[1].serv_data = NULL;                                               \
  275.     *output_class = clazz;                                                   \
  276.     return FT_Err_Ok;                                                        \
  277.   }
  278.  
  279. #define FT_DEFINE_SERVICEDESCREC2(class_, serv_id_1, serv_data_1,            \
  280.         serv_id_2, serv_data_2)                                              \
  281.   void                                                                       \
  282.   FT_Destroy_Class_##class_( FT_Library library,                             \
  283.                              FT_ServiceDescRec* clazz )                      \
  284.   {                                                                          \
  285.     FT_Memory memory = library->memory;                                      \
  286.     if ( clazz )                                                             \
  287.       FT_FREE( clazz );                                                      \
  288.   }                                                                          \
  289.                                                                              \
  290.   FT_Error                                                                   \
  291.   FT_Create_Class_##class_( FT_Library library,                              \
  292.                             FT_ServiceDescRec** output_class)                \
  293.   {                                                                          \
  294.     FT_ServiceDescRec*  clazz;                                               \
  295.     FT_Error          error;                                                 \
  296.     FT_Memory memory = library->memory;                                      \
  297.                                                                              \
  298.     if ( FT_ALLOC( clazz, sizeof(*clazz)*3 ) )                               \
  299.       return error;                                                          \
  300.     clazz[0].serv_id = serv_id_1;                                            \
  301.     clazz[0].serv_data = serv_data_1;                                        \
  302.     clazz[1].serv_id = serv_id_2;                                            \
  303.     clazz[1].serv_data = serv_data_2;                                        \
  304.     clazz[2].serv_id = NULL;                                                 \
  305.     clazz[2].serv_data = NULL;                                               \
  306.     *output_class = clazz;                                                   \
  307.     return FT_Err_Ok;                                                        \
  308.   }
  309.  
  310. #define FT_DEFINE_SERVICEDESCREC3(class_, serv_id_1, serv_data_1,            \
  311.         serv_id_2, serv_data_2, serv_id_3, serv_data_3)                      \
  312.   void                                                                       \
  313.   FT_Destroy_Class_##class_( FT_Library library,                             \
  314.                              FT_ServiceDescRec* clazz )                      \
  315.   {                                                                          \
  316.     FT_Memory memory = library->memory;                                      \
  317.     if ( clazz )                                                             \
  318.       FT_FREE( clazz );                                                      \
  319.   }                                                                          \
  320.                                                                              \
  321.   FT_Error                                                                   \
  322.   FT_Create_Class_##class_( FT_Library library,                              \
  323.                             FT_ServiceDescRec** output_class)                \
  324.   {                                                                          \
  325.     FT_ServiceDescRec*  clazz;                                               \
  326.     FT_Error          error;                                                 \
  327.     FT_Memory memory = library->memory;                                      \
  328.                                                                              \
  329.     if ( FT_ALLOC( clazz, sizeof(*clazz)*4 ) )                               \
  330.       return error;                                                          \
  331.     clazz[0].serv_id = serv_id_1;                                            \
  332.     clazz[0].serv_data = serv_data_1;                                        \
  333.     clazz[1].serv_id = serv_id_2;                                            \
  334.     clazz[1].serv_data = serv_data_2;                                        \
  335.     clazz[2].serv_id = serv_id_3;                                            \
  336.     clazz[2].serv_data = serv_data_3;                                        \
  337.     clazz[3].serv_id = NULL;                                                 \
  338.     clazz[3].serv_data = NULL;                                               \
  339.     *output_class = clazz;                                                   \
  340.     return FT_Err_Ok;                                                        \
  341.   }
  342.  
  343. #define FT_DEFINE_SERVICEDESCREC4(class_, serv_id_1, serv_data_1,            \
  344.         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
  345.         serv_id_4, serv_data_4)                                              \
  346.   void                                                                       \
  347.   FT_Destroy_Class_##class_( FT_Library library,                             \
  348.                              FT_ServiceDescRec* clazz )                      \
  349.   {                                                                          \
  350.     FT_Memory memory = library->memory;                                      \
  351.     if ( clazz )                                                             \
  352.       FT_FREE( clazz );                                                      \
  353.   }                                                                          \
  354.                                                                              \
  355.   FT_Error                                                                   \
  356.   FT_Create_Class_##class_( FT_Library library,                              \
  357.                             FT_ServiceDescRec** output_class)                \
  358.   {                                                                          \
  359.     FT_ServiceDescRec*  clazz;                                               \
  360.     FT_Error          error;                                                 \
  361.     FT_Memory memory = library->memory;                                      \
  362.                                                                              \
  363.     if ( FT_ALLOC( clazz, sizeof(*clazz)*5 ) )                               \
  364.       return error;                                                          \
  365.     clazz[0].serv_id = serv_id_1;                                            \
  366.     clazz[0].serv_data = serv_data_1;                                        \
  367.     clazz[1].serv_id = serv_id_2;                                            \
  368.     clazz[1].serv_data = serv_data_2;                                        \
  369.     clazz[2].serv_id = serv_id_3;                                            \
  370.     clazz[2].serv_data = serv_data_3;                                        \
  371.     clazz[3].serv_id = serv_id_4;                                            \
  372.     clazz[3].serv_data = serv_data_4;                                        \
  373.     clazz[4].serv_id = NULL;                                                 \
  374.     clazz[4].serv_data = NULL;                                               \
  375.     *output_class = clazz;                                                   \
  376.     return FT_Err_Ok;                                                        \
  377.   }
  378.  
  379. #define FT_DEFINE_SERVICEDESCREC5(class_, serv_id_1, serv_data_1,            \
  380.         serv_id_2, serv_data_2, serv_id_3, serv_data_3, serv_id_4,           \
  381.         serv_data_4, serv_id_5, serv_data_5)                                 \
  382.   void                                                                       \
  383.   FT_Destroy_Class_##class_( FT_Library library,                             \
  384.                              FT_ServiceDescRec* clazz )                      \
  385.   {                                                                          \
  386.     FT_Memory memory = library->memory;                                      \
  387.     if ( clazz )                                                             \
  388.       FT_FREE( clazz );                                                      \
  389.   }                                                                          \
  390.                                                                              \
  391.   FT_Error                                                                   \
  392.   FT_Create_Class_##class_( FT_Library library,                              \
  393.                             FT_ServiceDescRec** output_class)                \
  394.   {                                                                          \
  395.     FT_ServiceDescRec*  clazz;                                               \
  396.     FT_Error          error;                                                 \
  397.     FT_Memory memory = library->memory;                                      \
  398.                                                                              \
  399.     if ( FT_ALLOC( clazz, sizeof(*clazz)*6 ) )                               \
  400.       return error;                                                          \
  401.     clazz[0].serv_id = serv_id_1;                                            \
  402.     clazz[0].serv_data = serv_data_1;                                        \
  403.     clazz[1].serv_id = serv_id_2;                                            \
  404.     clazz[1].serv_data = serv_data_2;                                        \
  405.     clazz[2].serv_id = serv_id_3;                                            \
  406.     clazz[2].serv_data = serv_data_3;                                        \
  407.     clazz[3].serv_id = serv_id_4;                                            \
  408.     clazz[3].serv_data = serv_data_4;                                        \
  409.     clazz[4].serv_id = serv_id_5;                                            \
  410.     clazz[4].serv_data = serv_data_5;                                        \
  411.     clazz[5].serv_id = NULL;                                                 \
  412.     clazz[5].serv_data = NULL;                                               \
  413.     *output_class = clazz;                                                   \
  414.     return FT_Err_Ok;                                                        \
  415.   }
  416.  
  417. #define FT_DEFINE_SERVICEDESCREC6(class_, serv_id_1, serv_data_1,            \
  418.         serv_id_2, serv_data_2, serv_id_3, serv_data_3,                      \
  419.         serv_id_4, serv_data_4, serv_id_5, serv_data_5,                      \
  420.         serv_id_6, serv_data_6)                                              \
  421.   void                                                                       \
  422.   FT_Destroy_Class_##class_( FT_Library library,                             \
  423.                              FT_ServiceDescRec* clazz )                      \
  424.   {                                                                          \
  425.     FT_Memory memory = library->memory;                                      \
  426.     if ( clazz )                                                             \
  427.       FT_FREE( clazz );                                                      \
  428.   }                                                                          \
  429.                                                                              \
  430.   FT_Error                                                                   \
  431.   FT_Create_Class_##class_( FT_Library library,                              \
  432.                             FT_ServiceDescRec** output_class)                \
  433.   {                                                                          \
  434.     FT_ServiceDescRec*  clazz;                                               \
  435.     FT_Error          error;                                                 \
  436.     FT_Memory memory = library->memory;                                      \
  437.                                                                              \
  438.     if ( FT_ALLOC( clazz, sizeof(*clazz)*7 ) )                               \
  439.       return error;                                                          \
  440.     clazz[0].serv_id = serv_id_1;                                            \
  441.     clazz[0].serv_data = serv_data_1;                                        \
  442.     clazz[1].serv_id = serv_id_2;                                            \
  443.     clazz[1].serv_data = serv_data_2;                                        \
  444.     clazz[2].serv_id = serv_id_3;                                            \
  445.     clazz[2].serv_data = serv_data_3;                                        \
  446.     clazz[3].serv_id = serv_id_4;                                            \
  447.     clazz[3].serv_data = serv_data_4;                                        \
  448.     clazz[4].serv_id = serv_id_5;                                            \
  449.     clazz[4].serv_data = serv_data_5;                                        \
  450.     clazz[5].serv_id = serv_id_6;                                            \
  451.     clazz[5].serv_data = serv_data_6;                                        \
  452.     clazz[6].serv_id = NULL;                                                 \
  453.     clazz[6].serv_data = NULL;                                               \
  454.     *output_class = clazz;                                                   \
  455.     return FT_Err_Ok;                                                        \
  456.   }
  457. #endif /* FT_CONFIG_OPTION_PIC */
  458.  
  459.   /*
  460.    *  Parse a list of FT_ServiceDescRec descriptors and look for
  461.    *  a specific service by ID.  Note that the last element in the
  462.    *  array must be { NULL, NULL }, and that the function should
  463.    *  return NULL if the service isn't available.
  464.    *
  465.    *  This function can be used by modules to implement their
  466.    *  `get_service' method.
  467.    */
  468.   FT_BASE( FT_Pointer )
  469.   ft_service_list_lookup( FT_ServiceDesc  service_descriptors,
  470.                           const char*     service_id );
  471.  
  472.  
  473.   /*************************************************************************/
  474.   /*************************************************************************/
  475.   /*****                                                               *****/
  476.   /*****             S E R V I C E S   C A C H E                       *****/
  477.   /*****                                                               *****/
  478.   /*************************************************************************/
  479.   /*************************************************************************/
  480.  
  481.   /*
  482.    *  This structure is used to store a cache for several frequently used
  483.    *  services.  It is the type of `face->internal->services'.  You
  484.    *  should only use FT_FACE_LOOKUP_SERVICE to access it.
  485.    *
  486.    *  All fields should have the type FT_Pointer to relax compilation
  487.    *  dependencies.  We assume the developer isn't completely stupid.
  488.    *
  489.    *  Each field must be named `service_XXXX' where `XXX' corresponds to
  490.    *  the correct FT_SERVICE_ID_XXXX macro.  See the definition of
  491.    *  FT_FACE_LOOKUP_SERVICE below how this is implemented.
  492.    *
  493.    */
  494.   typedef struct  FT_ServiceCacheRec_
  495.   {
  496.     FT_Pointer  service_POSTSCRIPT_FONT_NAME;
  497.     FT_Pointer  service_MULTI_MASTERS;
  498.     FT_Pointer  service_GLYPH_DICT;
  499.     FT_Pointer  service_PFR_METRICS;
  500.     FT_Pointer  service_WINFNT;
  501.  
  502.   } FT_ServiceCacheRec, *FT_ServiceCache;
  503.  
  504.  
  505.   /*
  506.    *  A magic number used within the services cache.
  507.    */
  508. #define FT_SERVICE_UNAVAILABLE  ((FT_Pointer)-2)  /* magic number */
  509.  
  510.  
  511.   /*
  512.    * @macro:
  513.    *   FT_FACE_LOOKUP_SERVICE
  514.    *
  515.    * @description:
  516.    *   This macro is used to lookup a service from a face's driver module
  517.    *   using its cache.
  518.    *
  519.    * @input:
  520.    *   face::
  521.    *     The source face handle containing the cache.
  522.    *
  523.    *   field ::
  524.    *     The field name in the cache.
  525.    *
  526.    *   id ::
  527.    *     The service ID.
  528.    *
  529.    * @output:
  530.    *   ptr ::
  531.    *     A variable receiving the service data.  NULL if not available.
  532.    */
  533. #ifdef __cplusplus
  534.  
  535. #define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
  536.   FT_BEGIN_STMNT                                               \
  537.     FT_Pointer   svc;                                          \
  538.     FT_Pointer*  Pptr = (FT_Pointer*)&(ptr);                   \
  539.                                                                \
  540.                                                                \
  541.     svc = FT_FACE( face )->internal->services. service_ ## id; \
  542.     if ( svc == FT_SERVICE_UNAVAILABLE )                       \
  543.       svc = NULL;                                              \
  544.     else if ( svc == NULL )                                    \
  545.     {                                                          \
  546.       FT_FACE_FIND_SERVICE( face, svc, id );                   \
  547.                                                                \
  548.       FT_FACE( face )->internal->services. service_ ## id =    \
  549.         (FT_Pointer)( svc != NULL ? svc                        \
  550.                                   : FT_SERVICE_UNAVAILABLE );  \
  551.     }                                                          \
  552.     *Pptr = svc;                                               \
  553.   FT_END_STMNT
  554.  
  555. #else /* !C++ */
  556.  
  557. #define FT_FACE_LOOKUP_SERVICE( face, ptr, id )                \
  558.   FT_BEGIN_STMNT                                               \
  559.     FT_Pointer  svc;                                           \
  560.                                                                \
  561.                                                                \
  562.     svc = FT_FACE( face )->internal->services. service_ ## id; \
  563.     if ( svc == FT_SERVICE_UNAVAILABLE )                       \
  564.       svc = NULL;                                              \
  565.     else if ( svc == NULL )                                    \
  566.     {                                                          \
  567.       FT_FACE_FIND_SERVICE( face, svc, id );                   \
  568.                                                                \
  569.       FT_FACE( face )->internal->services. service_ ## id =    \
  570.         (FT_Pointer)( svc != NULL ? svc                        \
  571.                                   : FT_SERVICE_UNAVAILABLE );  \
  572.     }                                                          \
  573.     ptr = svc;                                                 \
  574.   FT_END_STMNT
  575.  
  576. #endif /* !C++ */
  577.  
  578.   /*
  579.    *  A macro used to define new service structure types.
  580.    */
  581.  
  582. #define FT_DEFINE_SERVICE( name )            \
  583.   typedef struct FT_Service_ ## name ## Rec_ \
  584.     FT_Service_ ## name ## Rec ;             \
  585.   typedef struct FT_Service_ ## name ## Rec_ \
  586.     const * FT_Service_ ## name ;            \
  587.   struct FT_Service_ ## name ## Rec_
  588.  
  589.   /* */
  590.  
  591.   /*
  592.    *  The header files containing the services.
  593.    */
  594.  
  595. #define FT_SERVICE_BDF_H                <freetype/internal/services/svbdf.h>
  596. #define FT_SERVICE_CID_H                <freetype/internal/services/svcid.h>
  597. #define FT_SERVICE_GLYPH_DICT_H         <freetype/internal/services/svgldict.h>
  598. #define FT_SERVICE_GX_VALIDATE_H        <freetype/internal/services/svgxval.h>
  599. #define FT_SERVICE_KERNING_H            <freetype/internal/services/svkern.h>
  600. #define FT_SERVICE_MULTIPLE_MASTERS_H   <freetype/internal/services/svmm.h>
  601. #define FT_SERVICE_OPENTYPE_VALIDATE_H  <freetype/internal/services/svotval.h>
  602. #define FT_SERVICE_PFR_H                <freetype/internal/services/svpfr.h>
  603. #define FT_SERVICE_POSTSCRIPT_CMAPS_H   <freetype/internal/services/svpscmap.h>
  604. #define FT_SERVICE_POSTSCRIPT_INFO_H    <freetype/internal/services/svpsinfo.h>
  605. #define FT_SERVICE_POSTSCRIPT_NAME_H    <freetype/internal/services/svpostnm.h>
  606. #define FT_SERVICE_SFNT_H               <freetype/internal/services/svsfnt.h>
  607. #define FT_SERVICE_TRUETYPE_ENGINE_H    <freetype/internal/services/svtteng.h>
  608. #define FT_SERVICE_TT_CMAP_H            <freetype/internal/services/svttcmap.h>
  609. #define FT_SERVICE_WINFNT_H             <freetype/internal/services/svwinfnt.h>
  610. #define FT_SERVICE_XFREE86_NAME_H       <freetype/internal/services/svxf86nm.h>
  611. #define FT_SERVICE_TRUETYPE_GLYF_H      <freetype/internal/services/svttglyf.h>
  612.  
  613.  /* */
  614.  
  615. FT_END_HEADER
  616.  
  617. #endif /* __FTSERV_H__ */
  618.  
  619.  
  620. /* END */
  621.