zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
ftserv.h
Go to the documentation of this 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  /* */
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  /* */
169  /* <Macro> */
170  /* FT_DEFINE_SERVICEDESCREC1 .. FT_DEFINE_SERVICEDESCREC6 */
171  /* */
172  /* <Description> */
173  /* Used to initialize an array of FT_ServiceDescRec structures. */
174  /* */
175  /* When FT_CONFIG_OPTION_PIC is defined a `create' function needs to */
176  /* be called with a pointer to return an allocated array. As soon as */
177  /* it is no longer needed, a `destroy' function needs to be called to */
178  /* release that allocation. */
179  /* */
180  /* These functions should be manually called from the `pic_init' and */
181  /* `pic_free' functions of your module (see FT_DEFINE_MODULE). */
182  /* */
183  /* When FT_CONFIG_OPTION_PIC is not defined the array will be */
184  /* allocated in the global scope (or the scope where the macro is */
185  /* used). */
186  /* */
187 #ifndef FT_CONFIG_OPTION_PIC
188 
189 #define FT_DEFINE_SERVICEDESCREC1( class_, \
190  serv_id_1, serv_data_1 ) \
191  static const FT_ServiceDescRec class_[] = \
192  { \
193  { serv_id_1, serv_data_1 }, \
194  { NULL, NULL } \
195  };
196 
197 #define FT_DEFINE_SERVICEDESCREC2( class_, \
198  serv_id_1, serv_data_1, \
199  serv_id_2, serv_data_2 ) \
200  static const FT_ServiceDescRec class_[] = \
201  { \
202  { serv_id_1, serv_data_1 }, \
203  { serv_id_2, serv_data_2 }, \
204  { NULL, NULL } \
205  };
206 
207 #define FT_DEFINE_SERVICEDESCREC3( class_, \
208  serv_id_1, serv_data_1, \
209  serv_id_2, serv_data_2, \
210  serv_id_3, serv_data_3 ) \
211  static const FT_ServiceDescRec class_[] = \
212  { \
213  { serv_id_1, serv_data_1 }, \
214  { serv_id_2, serv_data_2 }, \
215  { serv_id_3, serv_data_3 }, \
216  { NULL, NULL } \
217  };
218 
219 #define FT_DEFINE_SERVICEDESCREC4( class_, \
220  serv_id_1, serv_data_1, \
221  serv_id_2, serv_data_2, \
222  serv_id_3, serv_data_3, \
223  serv_id_4, serv_data_4 ) \
224  static const FT_ServiceDescRec class_[] = \
225  { \
226  { serv_id_1, serv_data_1 }, \
227  { serv_id_2, serv_data_2 }, \
228  { serv_id_3, serv_data_3 }, \
229  { serv_id_4, serv_data_4 }, \
230  { NULL, NULL } \
231  };
232 
233 #define FT_DEFINE_SERVICEDESCREC5( class_, \
234  serv_id_1, serv_data_1, \
235  serv_id_2, serv_data_2, \
236  serv_id_3, serv_data_3, \
237  serv_id_4, serv_data_4, \
238  serv_id_5, serv_data_5 ) \
239  static const FT_ServiceDescRec class_[] = \
240  { \
241  { serv_id_1, serv_data_1 }, \
242  { serv_id_2, serv_data_2 }, \
243  { serv_id_3, serv_data_3 }, \
244  { serv_id_4, serv_data_4 }, \
245  { serv_id_5, serv_data_5 }, \
246  { NULL, NULL } \
247  };
248 
249 #define FT_DEFINE_SERVICEDESCREC6( class_, \
250  serv_id_1, serv_data_1, \
251  serv_id_2, serv_data_2, \
252  serv_id_3, serv_data_3, \
253  serv_id_4, serv_data_4, \
254  serv_id_5, serv_data_5, \
255  serv_id_6, serv_data_6 ) \
256  static const FT_ServiceDescRec class_[] = \
257  { \
258  { serv_id_1, serv_data_1 }, \
259  { serv_id_2, serv_data_2 }, \
260  { serv_id_3, serv_data_3 }, \
261  { serv_id_4, serv_data_4 }, \
262  { serv_id_5, serv_data_5 }, \
263  { serv_id_6, serv_data_6 }, \
264  { NULL, NULL } \
265  };
266 
267 #else /* FT_CONFIG_OPTION_PIC */
268 
269 #define FT_DEFINE_SERVICEDESCREC1( class_, \
270  serv_id_1, serv_data_1 ) \
271  void \
272  FT_Destroy_Class_ ## class_( FT_Library library, \
273  FT_ServiceDescRec* clazz ) \
274  { \
275  FT_Memory memory = library->memory; \
276  \
277  \
278  if ( clazz ) \
279  FT_FREE( clazz ); \
280  } \
281  \
282  FT_Error \
283  FT_Create_Class_ ## class_( FT_Library library, \
284  FT_ServiceDescRec** output_class ) \
285  { \
286  FT_ServiceDescRec* clazz; \
287  FT_Error error; \
288  FT_Memory memory = library->memory; \
289  \
290  \
291  if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 2 ) ) \
292  return error; \
293  \
294  clazz[0].serv_id = serv_id_1; \
295  clazz[0].serv_data = serv_data_1; \
296  clazz[1].serv_id = NULL; \
297  clazz[1].serv_data = NULL; \
298  \
299  *output_class = clazz; \
300  \
301  return FT_Err_Ok; \
302  }
303 
304 #define FT_DEFINE_SERVICEDESCREC2( class_, \
305  serv_id_1, serv_data_1, \
306  serv_id_2, serv_data_2 ) \
307  void \
308  FT_Destroy_Class_ ## class_( FT_Library library, \
309  FT_ServiceDescRec* clazz ) \
310  { \
311  FT_Memory memory = library->memory; \
312  \
313  \
314  if ( clazz ) \
315  FT_FREE( clazz ); \
316  } \
317  \
318  FT_Error \
319  FT_Create_Class_ ## class_( FT_Library library, \
320  FT_ServiceDescRec** output_class ) \
321  { \
322  FT_ServiceDescRec* clazz; \
323  FT_Error error; \
324  FT_Memory memory = library->memory; \
325  \
326  \
327  if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 3 ) ) \
328  return error; \
329  \
330  clazz[0].serv_id = serv_id_1; \
331  clazz[0].serv_data = serv_data_1; \
332  clazz[1].serv_id = serv_id_2; \
333  clazz[1].serv_data = serv_data_2; \
334  clazz[2].serv_id = NULL; \
335  clazz[2].serv_data = NULL; \
336  \
337  *output_class = clazz; \
338  \
339  return FT_Err_Ok; \
340  }
341 
342 #define FT_DEFINE_SERVICEDESCREC3( class_, \
343  serv_id_1, serv_data_1, \
344  serv_id_2, serv_data_2, \
345  serv_id_3, serv_data_3 ) \
346  void \
347  FT_Destroy_Class_ ## class_( FT_Library library, \
348  FT_ServiceDescRec* clazz ) \
349  { \
350  FT_Memory memory = library->memory; \
351  \
352  \
353  if ( clazz ) \
354  FT_FREE( clazz ); \
355  } \
356  \
357  FT_Error \
358  FT_Create_Class_ ## class_( FT_Library library, \
359  FT_ServiceDescRec** output_class ) \
360  { \
361  FT_ServiceDescRec* clazz; \
362  FT_Error error; \
363  FT_Memory memory = library->memory; \
364  \
365  \
366  if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 4 ) ) \
367  return error; \
368  \
369  clazz[0].serv_id = serv_id_1; \
370  clazz[0].serv_data = serv_data_1; \
371  clazz[1].serv_id = serv_id_2; \
372  clazz[1].serv_data = serv_data_2; \
373  clazz[2].serv_id = serv_id_3; \
374  clazz[2].serv_data = serv_data_3; \
375  clazz[3].serv_id = NULL; \
376  clazz[3].serv_data = NULL; \
377  \
378  *output_class = clazz; \
379  \
380  return FT_Err_Ok; \
381  }
382 
383 #define FT_DEFINE_SERVICEDESCREC4( class_, \
384  serv_id_1, serv_data_1, \
385  serv_id_2, serv_data_2, \
386  serv_id_3, serv_data_3, \
387  serv_id_4, serv_data_4 ) \
388  void \
389  FT_Destroy_Class_ ## class_( FT_Library library, \
390  FT_ServiceDescRec* clazz ) \
391  { \
392  FT_Memory memory = library->memory; \
393  \
394  \
395  if ( clazz ) \
396  FT_FREE( clazz ); \
397  } \
398  \
399  FT_Error \
400  FT_Create_Class_ ## class_( FT_Library library, \
401  FT_ServiceDescRec** output_class ) \
402  { \
403  FT_ServiceDescRec* clazz; \
404  FT_Error error; \
405  FT_Memory memory = library->memory; \
406  \
407  \
408  if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 5 ) ) \
409  return error; \
410  \
411  clazz[0].serv_id = serv_id_1; \
412  clazz[0].serv_data = serv_data_1; \
413  clazz[1].serv_id = serv_id_2; \
414  clazz[1].serv_data = serv_data_2; \
415  clazz[2].serv_id = serv_id_3; \
416  clazz[2].serv_data = serv_data_3; \
417  clazz[3].serv_id = serv_id_4; \
418  clazz[3].serv_data = serv_data_4; \
419  clazz[4].serv_id = NULL; \
420  clazz[4].serv_data = NULL; \
421  \
422  *output_class = clazz; \
423  \
424  return FT_Err_Ok; \
425  }
426 
427 #define FT_DEFINE_SERVICEDESCREC5( class_, \
428  serv_id_1, serv_data_1, \
429  serv_id_2, serv_data_2, \
430  serv_id_3, serv_data_3, \
431  serv_id_4, serv_data_4, \
432  serv_id_5, serv_data_5 ) \
433  void \
434  FT_Destroy_Class_ ## class_( FT_Library library, \
435  FT_ServiceDescRec* clazz ) \
436  { \
437  FT_Memory memory = library->memory; \
438  \
439  \
440  if ( clazz ) \
441  FT_FREE( clazz ); \
442  } \
443  \
444  FT_Error \
445  FT_Create_Class_ ## class_( FT_Library library, \
446  FT_ServiceDescRec** output_class ) \
447  { \
448  FT_ServiceDescRec* clazz; \
449  FT_Error error; \
450  FT_Memory memory = library->memory; \
451  \
452  \
453  if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 6 ) ) \
454  return error; \
455  \
456  clazz[0].serv_id = serv_id_1; \
457  clazz[0].serv_data = serv_data_1; \
458  clazz[1].serv_id = serv_id_2; \
459  clazz[1].serv_data = serv_data_2; \
460  clazz[2].serv_id = serv_id_3; \
461  clazz[2].serv_data = serv_data_3; \
462  clazz[3].serv_id = serv_id_4; \
463  clazz[3].serv_data = serv_data_4; \
464  clazz[4].serv_id = serv_id_5; \
465  clazz[4].serv_data = serv_data_5; \
466  clazz[5].serv_id = NULL; \
467  clazz[5].serv_data = NULL; \
468  \
469  *output_class = clazz; \
470  \
471  return FT_Err_Ok; \
472  }
473 
474 #define FT_DEFINE_SERVICEDESCREC6( class_, \
475  serv_id_1, serv_data_1, \
476  serv_id_2, serv_data_2, \
477  serv_id_3, serv_data_3, \
478  serv_id_4, serv_data_4, \
479  serv_id_5, serv_data_5, \
480  serv_id_6, serv_data_6 ) \
481  void \
482  FT_Destroy_Class_ ## class_( FT_Library library, \
483  FT_ServiceDescRec* clazz ) \
484  { \
485  FT_Memory memory = library->memory; \
486  \
487  \
488  if ( clazz ) \
489  FT_FREE( clazz ); \
490  } \
491  \
492  FT_Error \
493  FT_Create_Class_ ## class_( FT_Library library, \
494  FT_ServiceDescRec** output_class) \
495  { \
496  FT_ServiceDescRec* clazz; \
497  FT_Error error; \
498  FT_Memory memory = library->memory; \
499  \
500  \
501  if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 7 ) ) \
502  return error; \
503  \
504  clazz[0].serv_id = serv_id_1; \
505  clazz[0].serv_data = serv_data_1; \
506  clazz[1].serv_id = serv_id_2; \
507  clazz[1].serv_data = serv_data_2; \
508  clazz[2].serv_id = serv_id_3; \
509  clazz[2].serv_data = serv_data_3; \
510  clazz[3].serv_id = serv_id_4; \
511  clazz[3].serv_data = serv_data_4; \
512  clazz[4].serv_id = serv_id_5; \
513  clazz[4].serv_data = serv_data_5; \
514  clazz[5].serv_id = serv_id_6; \
515  clazz[5].serv_data = serv_data_6; \
516  clazz[6].serv_id = NULL; \
517  clazz[6].serv_data = NULL; \
518  \
519  *output_class = clazz; \
520  \
521  return FT_Err_Ok; \
522  }
523 
524 #endif /* FT_CONFIG_OPTION_PIC */
525 
526 
527  /*
528  * Parse a list of FT_ServiceDescRec descriptors and look for
529  * a specific service by ID. Note that the last element in the
530  * array must be { NULL, NULL }, and that the function should
531  * return NULL if the service isn't available.
532  *
533  * This function can be used by modules to implement their
534  * `get_service' method.
535  */
536  FT_BASE( FT_Pointer )
537  ft_service_list_lookup( FT_ServiceDesc service_descriptors,
538  const char* service_id );
539 
540 
541  /*************************************************************************/
542  /*************************************************************************/
543  /***** *****/
544  /***** S E R V I C E S C A C H E *****/
545  /***** *****/
546  /*************************************************************************/
547  /*************************************************************************/
548 
549  /*
550  * This structure is used to store a cache for several frequently used
551  * services. It is the type of `face->internal->services'. You
552  * should only use FT_FACE_LOOKUP_SERVICE to access it.
553  *
554  * All fields should have the type FT_Pointer to relax compilation
555  * dependencies. We assume the developer isn't completely stupid.
556  *
557  * Each field must be named `service_XXXX' where `XXX' corresponds to
558  * the correct FT_SERVICE_ID_XXXX macro. See the definition of
559  * FT_FACE_LOOKUP_SERVICE below how this is implemented.
560  *
561  */
562  typedef struct FT_ServiceCacheRec_
563  {
564  FT_Pointer service_POSTSCRIPT_FONT_NAME;
565  FT_Pointer service_MULTI_MASTERS;
566  FT_Pointer service_GLYPH_DICT;
567  FT_Pointer service_PFR_METRICS;
568  FT_Pointer service_WINFNT;
569 
570  } FT_ServiceCacheRec, *FT_ServiceCache;
571 
572 
573  /*
574  * A magic number used within the services cache.
575  */
576 #define FT_SERVICE_UNAVAILABLE ((FT_Pointer)-2) /* magic number */
577 
578 
579  /*
580  * @macro:
581  * FT_FACE_LOOKUP_SERVICE
582  *
583  * @description:
584  * This macro is used to lookup a service from a face's driver module
585  * using its cache.
586  *
587  * @input:
588  * face::
589  * The source face handle containing the cache.
590  *
591  * field ::
592  * The field name in the cache.
593  *
594  * id ::
595  * The service ID.
596  *
597  * @output:
598  * ptr ::
599  * A variable receiving the service data. NULL if not available.
600  */
601 #ifdef __cplusplus
602 
603 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id ) \
604  FT_BEGIN_STMNT \
605  FT_Pointer svc; \
606  FT_Pointer* Pptr = (FT_Pointer*)&(ptr); \
607  \
608  \
609  svc = FT_FACE( face )->internal->services. service_ ## id; \
610  if ( svc == FT_SERVICE_UNAVAILABLE ) \
611  svc = NULL; \
612  else if ( svc == NULL ) \
613  { \
614  FT_FACE_FIND_SERVICE( face, svc, id ); \
615  \
616  FT_FACE( face )->internal->services. service_ ## id = \
617  (FT_Pointer)( svc != NULL ? svc \
618  : FT_SERVICE_UNAVAILABLE ); \
619  } \
620  *Pptr = svc; \
621  FT_END_STMNT
622 
623 #else /* !C++ */
624 
625 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id ) \
626  FT_BEGIN_STMNT \
627  FT_Pointer svc; \
628  \
629  \
630  svc = FT_FACE( face )->internal->services. service_ ## id; \
631  if ( svc == FT_SERVICE_UNAVAILABLE ) \
632  svc = NULL; \
633  else if ( svc == NULL ) \
634  { \
635  FT_FACE_FIND_SERVICE( face, svc, id ); \
636  \
637  FT_FACE( face )->internal->services. service_ ## id = \
638  (FT_Pointer)( svc != NULL ? svc \
639  : FT_SERVICE_UNAVAILABLE ); \
640  } \
641  ptr = svc; \
642  FT_END_STMNT
643 
644 #endif /* !C++ */
645 
646  /*
647  * A macro used to define new service structure types.
648  */
649 
650 #define FT_DEFINE_SERVICE( name ) \
651  typedef struct FT_Service_ ## name ## Rec_ \
652  FT_Service_ ## name ## Rec ; \
653  typedef struct FT_Service_ ## name ## Rec_ \
654  const * FT_Service_ ## name ; \
655  struct FT_Service_ ## name ## Rec_
656 
657  /* */
658 
659  /*
660  * The header files containing the services.
661  */
662 
663 #define FT_SERVICE_BDF_H <freetype/internal/services/svbdf.h>
664 #define FT_SERVICE_CID_H <freetype/internal/services/svcid.h>
665 #define FT_SERVICE_GLYPH_DICT_H <freetype/internal/services/svgldict.h>
666 #define FT_SERVICE_GX_VALIDATE_H <freetype/internal/services/svgxval.h>
667 #define FT_SERVICE_KERNING_H <freetype/internal/services/svkern.h>
668 #define FT_SERVICE_MULTIPLE_MASTERS_H <freetype/internal/services/svmm.h>
669 #define FT_SERVICE_OPENTYPE_VALIDATE_H <freetype/internal/services/svotval.h>
670 #define FT_SERVICE_PFR_H <freetype/internal/services/svpfr.h>
671 #define FT_SERVICE_POSTSCRIPT_CMAPS_H <freetype/internal/services/svpscmap.h>
672 #define FT_SERVICE_POSTSCRIPT_INFO_H <freetype/internal/services/svpsinfo.h>
673 #define FT_SERVICE_POSTSCRIPT_NAME_H <freetype/internal/services/svpostnm.h>
674 #define FT_SERVICE_SFNT_H <freetype/internal/services/svsfnt.h>
675 #define FT_SERVICE_TRUETYPE_ENGINE_H <freetype/internal/services/svtteng.h>
676 #define FT_SERVICE_TT_CMAP_H <freetype/internal/services/svttcmap.h>
677 #define FT_SERVICE_WINFNT_H <freetype/internal/services/svwinfnt.h>
678 #define FT_SERVICE_XFREE86_NAME_H <freetype/internal/services/svxf86nm.h>
679 #define FT_SERVICE_TRUETYPE_GLYF_H <freetype/internal/services/svttglyf.h>
680 
681  /* */
682 
683 FT_END_HEADER
684 
685 #endif /* __FTSERV_H__ */
686 
687 
688 /* END */
ft_service_list_lookup
ft_service_list_lookup(FT_ServiceDesc service_descriptors, const char *service_id)
Definition: ftobjs.c:47
FT_ServiceDescRec
struct FT_ServiceDescRec_ FT_ServiceDescRec
FT_END_HEADER
#define FT_END_HEADER
Definition: ftheader.h:54
FT_ServiceCacheRec_::service_GLYPH_DICT
FT_Pointer service_GLYPH_DICT
Definition: ftserv.h:566
FT_ServiceCacheRec_::service_POSTSCRIPT_FONT_NAME
FT_Pointer service_POSTSCRIPT_FONT_NAME
Definition: ftserv.h:564
FT_ServiceCacheRec_::service_MULTI_MASTERS
FT_Pointer service_MULTI_MASTERS
Definition: ftserv.h:565
FT_ServiceCacheRec
struct FT_ServiceCacheRec_ FT_ServiceCacheRec
FT_ServiceCacheRec_
Definition: ftserv.h:562
FT_BEGIN_HEADER
#define FT_BEGIN_HEADER
Definition: ftheader.h:36
FT_ServiceDescRec_::serv_id
const char * serv_id
Definition: ftserv.h:159
FT_ServiceCacheRec_::service_WINFNT
FT_Pointer service_WINFNT
Definition: ftserv.h:568
FT_Pointer
void * FT_Pointer
Definition: fttypes.h:307
FT_ServiceDescRec_::serv_data
const void * serv_data
Definition: ftserv.h:160
FT_ServiceCache
struct FT_ServiceCacheRec_ * FT_ServiceCache
FT_ServiceCacheRec_::service_PFR_METRICS
FT_Pointer service_PFR_METRICS
Definition: ftserv.h:567
FT_ServiceDescRec_
Definition: ftserv.h:157
const
#define const
Definition: zconf.h:91
FT_BASE
#define FT_BASE(x)
Definition: ftconfig.h:478
FT_ServiceDesc
const FT_ServiceDescRec * FT_ServiceDesc
Definition: ftserv.h:164