/src/freetype/include/freetype/internal/ftserv.h

https://bitbucket.org/cabalistic/ogredeps/ · C++ Header · 688 lines · 458 code · 63 blank · 167 comment · 26 complexity · 50900979bf3135227b3b150b259fbd93 MD5 · raw file

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