projects / reactos.git / blob
? search:


91897177ba0d39d9a9798d99e33b776504a2950c
[reactos.git] / reactos / sdk / lib / 3rdparty / freetype / include / freetype / internal / ftserv.h
1 /***************************************************************************/
2 /* */
3 /* ftserv.h */
4 /* */
5 /* The FreeType services (specification only). */
6 /* */
7 /* Copyright 2003-2016 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 /*
38 * @macro:
39 * FT_FACE_FIND_SERVICE
40 *
41 * @description:
42 * This macro is used to look up a service from a face's driver module.
43 *
44 * @input:
45 * face ::
46 * The source face handle.
47 *
48 * id ::
49 * A string describing the service as defined in the service's
50 * header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
51 * `multi-masters'). It is automatically prefixed with
52 * `FT_SERVICE_ID_'.
53 *
54 * @output:
55 * ptr ::
56 * A variable that receives the service pointer. Will be NULL
57 * if not found.
58 */
59 #ifdef __cplusplus
60
61 #define FT_FACE_FIND_SERVICE( face, ptr, id ) \
62 FT_BEGIN_STMNT \
63 FT_Module module = FT_MODULE( FT_FACE( face )->driver ); \
64 FT_Pointer _tmp_ = NULL; \
65 FT_Pointer* _pptr_ = (FT_Pointer*)&(ptr); \
66 \
67 \
68 if ( module->clazz->get_interface ) \
69 _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
70 *_pptr_ = _tmp_; \
71 FT_END_STMNT
72
73 #else /* !C++ */
74
75 #define FT_FACE_FIND_SERVICE( face, ptr, id ) \
76 FT_BEGIN_STMNT \
77 FT_Module module = FT_MODULE( FT_FACE( face )->driver ); \
78 FT_Pointer _tmp_ = NULL; \
79 \
80 if ( module->clazz->get_interface ) \
81 _tmp_ = module->clazz->get_interface( module, FT_SERVICE_ID_ ## id ); \
82 ptr = _tmp_; \
83 FT_END_STMNT
84
85 #endif /* !C++ */
86
87
88 /*
89 * @macro:
90 * FT_FACE_FIND_GLOBAL_SERVICE
91 *
92 * @description:
93 * This macro is used to look up a service from all modules.
94 *
95 * @input:
96 * face ::
97 * The source face handle.
98 *
99 * id ::
100 * A string describing the service as defined in the service's
101 * header files (e.g. FT_SERVICE_ID_MULTI_MASTERS which expands to
102 * `multi-masters'). It is automatically prefixed with
103 * `FT_SERVICE_ID_'.
104 *
105 * @output:
106 * ptr ::
107 * A variable that receives the service pointer. Will be NULL
108 * if not found.
109 */
110 #ifdef __cplusplus
111
112 #define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id ) \
113 FT_BEGIN_STMNT \
114 FT_Module module = FT_MODULE( FT_FACE( face )->driver ); \
115 FT_Pointer _tmp_; \
116 FT_Pointer* _pptr_ = (FT_Pointer*)&(ptr); \
117 \
118 \
119 _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
120 *_pptr_ = _tmp_; \
121 FT_END_STMNT
122
123 #else /* !C++ */
124
125 #define FT_FACE_FIND_GLOBAL_SERVICE( face, ptr, id ) \
126 FT_BEGIN_STMNT \
127 FT_Module module = FT_MODULE( FT_FACE( face )->driver ); \
128 FT_Pointer _tmp_; \
129 \
130 \
131 _tmp_ = ft_module_get_service( module, FT_SERVICE_ID_ ## id ); \
132 ptr = _tmp_; \
133 FT_END_STMNT
134
135 #endif /* !C++ */
136
137
138 /*************************************************************************/
139 /*************************************************************************/
140 /***** *****/
141 /***** S E R V I C E D E S C R I P T O R S *****/
142 /***** *****/
143 /*************************************************************************/
144 /*************************************************************************/
145
146 /*
147 * The following structure is used to _describe_ a given service
148 * to the library. This is useful to build simple static service lists.
149 */
150 typedef struct FT_ServiceDescRec_
151 {
152 const char* serv_id; /* service name */
153 const void* serv_data; /* service pointer/data */
154
155 } FT_ServiceDescRec;
156
157 typedef const FT_ServiceDescRec* FT_ServiceDesc;
158
159
160 /*************************************************************************/
161 /* */
162 /* <Macro> */
163 /* FT_DEFINE_SERVICEDESCREC1 */
164 /* FT_DEFINE_SERVICEDESCREC2 */
165 /* FT_DEFINE_SERVICEDESCREC3 */
166 /* FT_DEFINE_SERVICEDESCREC4 */
167 /* FT_DEFINE_SERVICEDESCREC5 */
168 /* FT_DEFINE_SERVICEDESCREC6 */
169 /* FT_DEFINE_SERVICEDESCREC7 */
170 /* */
171 /* <Description> */
172 /* Used to initialize an array of FT_ServiceDescRec structures. */
173 /* */
174 /* When FT_CONFIG_OPTION_PIC is defined a `create' function needs to */
175 /* be called with a pointer to return an allocated array. As soon as */
176 /* it is no longer needed, a `destroy' function needs to be called to */
177 /* release that allocation. */
178 /* */
179 /* These functions should be manually 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 is */
184 /* used). */
185 /* */
186 #ifndef FT_CONFIG_OPTION_PIC
187
188 #define FT_DEFINE_SERVICEDESCREC1( class_, \
189 serv_id_1, serv_data_1 ) \
190 static const FT_ServiceDescRec class_[] = \
191 { \
192 { serv_id_1, serv_data_1 }, \
193 { NULL, NULL } \
194 };
195
196 #define FT_DEFINE_SERVICEDESCREC2( class_, \
197 serv_id_1, serv_data_1, \
198 serv_id_2, serv_data_2 ) \
199 static const FT_ServiceDescRec class_[] = \
200 { \
201 { serv_id_1, serv_data_1 }, \
202 { serv_id_2, serv_data_2 }, \
203 { NULL, NULL } \
204 };
205
206 #define FT_DEFINE_SERVICEDESCREC3( class_, \
207 serv_id_1, serv_data_1, \
208 serv_id_2, serv_data_2, \
209 serv_id_3, serv_data_3 ) \
210 static const FT_ServiceDescRec class_[] = \
211 { \
212 { serv_id_1, serv_data_1 }, \
213 { serv_id_2, serv_data_2 }, \
214 { serv_id_3, serv_data_3 }, \
215 { NULL, NULL } \
216 };
217
218 #define FT_DEFINE_SERVICEDESCREC4( 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 static const FT_ServiceDescRec class_[] = \
224 { \
225 { serv_id_1, serv_data_1 }, \
226 { serv_id_2, serv_data_2 }, \
227 { serv_id_3, serv_data_3 }, \
228 { serv_id_4, serv_data_4 }, \
229 { NULL, NULL } \
230 };
231
232 #define FT_DEFINE_SERVICEDESCREC5( class_, \
233 serv_id_1, serv_data_1, \
234 serv_id_2, serv_data_2, \
235 serv_id_3, serv_data_3, \
236 serv_id_4, serv_data_4, \
237 serv_id_5, serv_data_5 ) \
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 { NULL, NULL } \
246 };
247
248 #define FT_DEFINE_SERVICEDESCREC6( class_, \
249 serv_id_1, serv_data_1, \
250 serv_id_2, serv_data_2, \
251 serv_id_3, serv_data_3, \
252 serv_id_4, serv_data_4, \
253 serv_id_5, serv_data_5, \
254 serv_id_6, serv_data_6 ) \
255 static const FT_ServiceDescRec class_[] = \
256 { \
257 { serv_id_1, serv_data_1 }, \
258 { serv_id_2, serv_data_2 }, \
259 { serv_id_3, serv_data_3 }, \
260 { serv_id_4, serv_data_4 }, \
261 { serv_id_5, serv_data_5 }, \
262 { serv_id_6, serv_data_6 }, \
263 { NULL, NULL } \
264 };
265
266 #define FT_DEFINE_SERVICEDESCREC7( class_, \
267 serv_id_1, serv_data_1, \
268 serv_id_2, serv_data_2, \
269 serv_id_3, serv_data_3, \
270 serv_id_4, serv_data_4, \
271 serv_id_5, serv_data_5, \
272 serv_id_6, serv_data_6, \
273 serv_id_7, serv_data_7 ) \
274 static const FT_ServiceDescRec class_[] = \
275 { \
276 { serv_id_1, serv_data_1 }, \
277 { serv_id_2, serv_data_2 }, \
278 { serv_id_3, serv_data_3 }, \
279 { serv_id_4, serv_data_4 }, \
280 { serv_id_5, serv_data_5 }, \
281 { serv_id_6, serv_data_6 }, \
282 { serv_id_7, serv_data_7 }, \
283 { NULL, NULL } \
284 };
285
286 #else /* FT_CONFIG_OPTION_PIC */
287
288 #define FT_DEFINE_SERVICEDESCREC1( class_, \
289 serv_id_1, serv_data_1 ) \
290 void \
291 FT_Destroy_Class_ ## class_( FT_Library library, \
292 FT_ServiceDescRec* clazz ) \
293 { \
294 FT_Memory memory = library->memory; \
295 \
296 \
297 if ( clazz ) \
298 FT_FREE( clazz ); \
299 } \
300 \
301 FT_Error \
302 FT_Create_Class_ ## class_( FT_Library library, \
303 FT_ServiceDescRec** output_class ) \
304 { \
305 FT_ServiceDescRec* clazz = NULL; \
306 FT_Error error; \
307 FT_Memory memory = library->memory; \
308 \
309 \
310 if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 2 ) ) \
311 return error; \
312 \
313 clazz[0].serv_id = serv_id_1; \
314 clazz[0].serv_data = serv_data_1; \
315 clazz[1].serv_id = NULL; \
316 clazz[1].serv_data = NULL; \
317 \
318 *output_class = clazz; \
319 \
320 return FT_Err_Ok; \
321 }
322
323 #define FT_DEFINE_SERVICEDESCREC2( class_, \
324 serv_id_1, serv_data_1, \
325 serv_id_2, serv_data_2 ) \
326 void \
327 FT_Destroy_Class_ ## class_( FT_Library library, \
328 FT_ServiceDescRec* clazz ) \
329 { \
330 FT_Memory memory = library->memory; \
331 \
332 \
333 if ( clazz ) \
334 FT_FREE( clazz ); \
335 } \
336 \
337 FT_Error \
338 FT_Create_Class_ ## class_( FT_Library library, \
339 FT_ServiceDescRec** output_class ) \
340 { \
341 FT_ServiceDescRec* clazz = NULL; \
342 FT_Error error; \
343 FT_Memory memory = library->memory; \
344 \
345 \
346 if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 3 ) ) \
347 return error; \
348 \
349 clazz[0].serv_id = serv_id_1; \
350 clazz[0].serv_data = serv_data_1; \
351 clazz[1].serv_id = serv_id_2; \
352 clazz[1].serv_data = serv_data_2; \
353 clazz[2].serv_id = NULL; \
354 clazz[2].serv_data = NULL; \
355 \
356 *output_class = clazz; \
357 \
358 return FT_Err_Ok; \
359 }
360
361 #define FT_DEFINE_SERVICEDESCREC3( class_, \
362 serv_id_1, serv_data_1, \
363 serv_id_2, serv_data_2, \
364 serv_id_3, serv_data_3 ) \
365 void \
366 FT_Destroy_Class_ ## class_( FT_Library library, \
367 FT_ServiceDescRec* clazz ) \
368 { \
369 FT_Memory memory = library->memory; \
370 \
371 \
372 if ( clazz ) \
373 FT_FREE( clazz ); \
374 } \
375 \
376 FT_Error \
377 FT_Create_Class_ ## class_( FT_Library library, \
378 FT_ServiceDescRec** output_class ) \
379 { \
380 FT_ServiceDescRec* clazz = NULL; \
381 FT_Error error; \
382 FT_Memory memory = library->memory; \
383 \
384 \
385 if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 4 ) ) \
386 return error; \
387 \
388 clazz[0].serv_id = serv_id_1; \
389 clazz[0].serv_data = serv_data_1; \
390 clazz[1].serv_id = serv_id_2; \
391 clazz[1].serv_data = serv_data_2; \
392 clazz[2].serv_id = serv_id_3; \
393 clazz[2].serv_data = serv_data_3; \
394 clazz[3].serv_id = NULL; \
395 clazz[3].serv_data = NULL; \
396 \
397 *output_class = clazz; \
398 \
399 return FT_Err_Ok; \
400 }
401
402 #define FT_DEFINE_SERVICEDESCREC4( class_, \
403 serv_id_1, serv_data_1, \
404 serv_id_2, serv_data_2, \
405 serv_id_3, serv_data_3, \
406 serv_id_4, serv_data_4 ) \
407 void \
408 FT_Destroy_Class_ ## class_( FT_Library library, \
409 FT_ServiceDescRec* clazz ) \
410 { \
411 FT_Memory memory = library->memory; \
412 \
413 \
414 if ( clazz ) \
415 FT_FREE( clazz ); \
416 } \
417 \
418 FT_Error \
419 FT_Create_Class_ ## class_( FT_Library library, \
420 FT_ServiceDescRec** output_class ) \
421 { \
422 FT_ServiceDescRec* clazz = NULL; \
423 FT_Error error; \
424 FT_Memory memory = library->memory; \
425 \
426 \
427 if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 5 ) ) \
428 return error; \
429 \
430 clazz[0].serv_id = serv_id_1; \
431 clazz[0].serv_data = serv_data_1; \
432 clazz[1].serv_id = serv_id_2; \
433 clazz[1].serv_data = serv_data_2; \
434 clazz[2].serv_id = serv_id_3; \
435 clazz[2].serv_data = serv_data_3; \
436 clazz[3].serv_id = serv_id_4; \
437 clazz[3].serv_data = serv_data_4; \
438 clazz[4].serv_id = NULL; \
439 clazz[4].serv_data = NULL; \
440 \
441 *output_class = clazz; \
442 \
443 return FT_Err_Ok; \
444 }
445
446 #define FT_DEFINE_SERVICEDESCREC5( class_, \
447 serv_id_1, serv_data_1, \
448 serv_id_2, serv_data_2, \
449 serv_id_3, serv_data_3, \
450 serv_id_4, serv_data_4, \
451 serv_id_5, serv_data_5 ) \
452 void \
453 FT_Destroy_Class_ ## class_( FT_Library library, \
454 FT_ServiceDescRec* clazz ) \
455 { \
456 FT_Memory memory = library->memory; \
457 \
458 \
459 if ( clazz ) \
460 FT_FREE( clazz ); \
461 } \
462 \
463 FT_Error \
464 FT_Create_Class_ ## class_( FT_Library library, \
465 FT_ServiceDescRec** output_class ) \
466 { \
467 FT_ServiceDescRec* clazz = NULL; \
468 FT_Error error; \
469 FT_Memory memory = library->memory; \
470 \
471 \
472 if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 6 ) ) \
473 return error; \
474 \
475 clazz[0].serv_id = serv_id_1; \
476 clazz[0].serv_data = serv_data_1; \
477 clazz[1].serv_id = serv_id_2; \
478 clazz[1].serv_data = serv_data_2; \
479 clazz[2].serv_id = serv_id_3; \
480 clazz[2].serv_data = serv_data_3; \
481 clazz[3].serv_id = serv_id_4; \
482 clazz[3].serv_data = serv_data_4; \
483 clazz[4].serv_id = serv_id_5; \
484 clazz[4].serv_data = serv_data_5; \
485 clazz[5].serv_id = NULL; \
486 clazz[5].serv_data = NULL; \
487 \
488 *output_class = clazz; \
489 \
490 return FT_Err_Ok; \
491 }
492
493 #define FT_DEFINE_SERVICEDESCREC6( class_, \
494 serv_id_1, serv_data_1, \
495 serv_id_2, serv_data_2, \
496 serv_id_3, serv_data_3, \
497 serv_id_4, serv_data_4, \
498 serv_id_5, serv_data_5, \
499 serv_id_6, serv_data_6 ) \
500 void \
501 FT_Destroy_Class_ ## class_( FT_Library library, \
502 FT_ServiceDescRec* clazz ) \
503 { \
504 FT_Memory memory = library->memory; \
505 \
506 \
507 if ( clazz ) \
508 FT_FREE( clazz ); \
509 } \
510 \
511 FT_Error \
512 FT_Create_Class_ ## class_( FT_Library library, \
513 FT_ServiceDescRec** output_class) \
514 { \
515 FT_ServiceDescRec* clazz = NULL; \
516 FT_Error error; \
517 FT_Memory memory = library->memory; \
518 \
519 \
520 if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 7 ) ) \
521 return error; \
522 \
523 clazz[0].serv_id = serv_id_1; \
524 clazz[0].serv_data = serv_data_1; \
525 clazz[1].serv_id = serv_id_2; \
526 clazz[1].serv_data = serv_data_2; \
527 clazz[2].serv_id = serv_id_3; \
528 clazz[2].serv_data = serv_data_3; \
529 clazz[3].serv_id = serv_id_4; \
530 clazz[3].serv_data = serv_data_4; \
531 clazz[4].serv_id = serv_id_5; \
532 clazz[4].serv_data = serv_data_5; \
533 clazz[5].serv_id = serv_id_6; \
534 clazz[5].serv_data = serv_data_6; \
535 clazz[6].serv_id = NULL; \
536 clazz[6].serv_data = NULL; \
537 \
538 *output_class = clazz; \
539 \
540 return FT_Err_Ok; \
541 }
542
543 #define FT_DEFINE_SERVICEDESCREC7( class_, \
544 serv_id_1, serv_data_1, \
545 serv_id_2, serv_data_2, \
546 serv_id_3, serv_data_3, \
547 serv_id_4, serv_data_4, \
548 serv_id_5, serv_data_5, \
549 serv_id_6, serv_data_6, \
550 serv_id_7, serv_data_7 ) \
551 void \
552 FT_Destroy_Class_ ## class_( FT_Library library, \
553 FT_ServiceDescRec* clazz ) \
554 { \
555 FT_Memory memory = library->memory; \
556 \
557 \
558 if ( clazz ) \
559 FT_FREE( clazz ); \
560 } \
561 \
562 FT_Error \
563 FT_Create_Class_ ## class_( FT_Library library, \
564 FT_ServiceDescRec** output_class) \
565 { \
566 FT_ServiceDescRec* clazz = NULL; \
567 FT_Error error; \
568 FT_Memory memory = library->memory; \
569 \
570 \
571 if ( FT_ALLOC( clazz, sizeof ( *clazz ) * 8 ) ) \
572 return error; \
573 \
574 clazz[0].serv_id = serv_id_1; \
575 clazz[0].serv_data = serv_data_1; \
576 clazz[1].serv_id = serv_id_2; \
577 clazz[1].serv_data = serv_data_2; \
578 clazz[2].serv_id = serv_id_3; \
579 clazz[2].serv_data = serv_data_3; \
580 clazz[3].serv_id = serv_id_4; \
581 clazz[3].serv_data = serv_data_4; \
582 clazz[4].serv_id = serv_id_5; \
583 clazz[4].serv_data = serv_data_5; \
584 clazz[5].serv_id = serv_id_6; \
585 clazz[5].serv_data = serv_data_6; \
586 clazz[6].serv_id = serv_id_7; \
587 clazz[6].serv_data = serv_data_7; \
588 clazz[7].serv_id = NULL; \
589 clazz[7].serv_data = NULL; \
590 \
591 *output_class = clazz; \
592 \
593 return FT_Err_Ok; \
594 }
595
596 #endif /* FT_CONFIG_OPTION_PIC */
597
598
599 /*
600 * Parse a list of FT_ServiceDescRec descriptors and look for
601 * a specific service by ID. Note that the last element in the
602 * array must be { NULL, NULL }, and that the function should
603 * return NULL if the service isn't available.
604 *
605 * This function can be used by modules to implement their
606 * `get_service' method.
607 */
608 FT_BASE( FT_Pointer )
609 ft_service_list_lookup( FT_ServiceDesc service_descriptors,
610 const char* service_id );
611
612
613 /*************************************************************************/
614 /*************************************************************************/
615 /***** *****/
616 /***** S E R V I C E S C A C H E *****/
617 /***** *****/
618 /*************************************************************************/
619 /*************************************************************************/
620
621 /*
622 * This structure is used to store a cache for several frequently used
623 * services. It is the type of `face->internal->services'. You
624 * should only use FT_FACE_LOOKUP_SERVICE to access it.
625 *
626 * All fields should have the type FT_Pointer to relax compilation
627 * dependencies. We assume the developer isn't completely stupid.
628 *
629 * Each field must be named `service_XXXX' where `XXX' corresponds to
630 * the correct FT_SERVICE_ID_XXXX macro. See the definition of
631 * FT_FACE_LOOKUP_SERVICE below how this is implemented.
632 *
633 */
634 typedef struct FT_ServiceCacheRec_
635 {
636 FT_Pointer service_POSTSCRIPT_FONT_NAME;
637 FT_Pointer service_MULTI_MASTERS;
638 FT_Pointer service_GLYPH_DICT;
639 FT_Pointer service_PFR_METRICS;
640 FT_Pointer service_WINFNT;
641
642 } FT_ServiceCacheRec, *FT_ServiceCache;
643
644
645 /*
646 * A magic number used within the services cache.
647 */
648
649 /* ensure that value `1' has the same width as a pointer */
650 #define FT_SERVICE_UNAVAILABLE ((FT_Pointer)~(FT_PtrDist)1)
651
652
653 /*
654 * @macro:
655 * FT_FACE_LOOKUP_SERVICE
656 *
657 * @description:
658 * This macro is used to lookup a service from a face's driver module
659 * using its cache.
660 *
661 * @input:
662 * face::
663 * The source face handle containing the cache.
664 *
665 * field ::
666 * The field name in the cache.
667 *
668 * id ::
669 * The service ID.
670 *
671 * @output:
672 * ptr ::
673 * A variable receiving the service data. NULL if not available.
674 */
675 #ifdef __cplusplus
676
677 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id ) \
678 FT_BEGIN_STMNT \
679 FT_Pointer svc; \
680 FT_Pointer* Pptr = (FT_Pointer*)&(ptr); \
681 \
682 \
683 svc = FT_FACE( face )->internal->services. service_ ## id; \
684 if ( svc == FT_SERVICE_UNAVAILABLE ) \
685 svc = NULL; \
686 else if ( svc == NULL ) \
687 { \
688 FT_FACE_FIND_SERVICE( face, svc, id ); \
689 \
690 FT_FACE( face )->internal->services. service_ ## id = \
691 (FT_Pointer)( svc != NULL ? svc \
692 : FT_SERVICE_UNAVAILABLE ); \
693 } \
694 *Pptr = svc; \
695 FT_END_STMNT
696
697 #else /* !C++ */
698
699 #define FT_FACE_LOOKUP_SERVICE( face, ptr, id ) \
700 FT_BEGIN_STMNT \
701 FT_Pointer svc; \
702 \
703 \
704 svc = FT_FACE( face )->internal->services. service_ ## id; \
705 if ( svc == FT_SERVICE_UNAVAILABLE ) \
706 svc = NULL; \
707 else if ( svc == NULL ) \
708 { \
709 FT_FACE_FIND_SERVICE( face, svc, id ); \
710 \
711 FT_FACE( face )->internal->services. service_ ## id = \
712 (FT_Pointer)( svc != NULL ? svc \
713 : FT_SERVICE_UNAVAILABLE ); \
714 } \
715 ptr = svc; \
716 FT_END_STMNT
717
718 #endif /* !C++ */
719
720 /*
721 * A macro used to define new service structure types.
722 */
723
724 #define FT_DEFINE_SERVICE( name ) \
725 typedef struct FT_Service_ ## name ## Rec_ \
726 FT_Service_ ## name ## Rec ; \
727 typedef struct FT_Service_ ## name ## Rec_ \
728 const * FT_Service_ ## name ; \
729 struct FT_Service_ ## name ## Rec_
730
731 /* */
732
733 /*
734 * The header files containing the services.
735 */
736
737 #define FT_SERVICE_BDF_H <freetype/internal/services/svbdf.h>
738 #define FT_SERVICE_CID_H <freetype/internal/services/svcid.h>
739 #define FT_SERVICE_GLYPH_DICT_H <freetype/internal/services/svgldict.h>
740 #define FT_SERVICE_GX_VALIDATE_H <freetype/internal/services/svgxval.h>
741 #define FT_SERVICE_KERNING_H <freetype/internal/services/svkern.h>
742 #define FT_SERVICE_MULTIPLE_MASTERS_H <freetype/internal/services/svmm.h>
743 #define FT_SERVICE_OPENTYPE_VALIDATE_H <freetype/internal/services/svotval.h>
744 #define FT_SERVICE_PFR_H <freetype/internal/services/svpfr.h>
745 #define FT_SERVICE_POSTSCRIPT_CMAPS_H <freetype/internal/services/svpscmap.h>
746 #define FT_SERVICE_POSTSCRIPT_INFO_H <freetype/internal/services/svpsinfo.h>
747 #define FT_SERVICE_POSTSCRIPT_NAME_H <freetype/internal/services/svpostnm.h>
748 #define FT_SERVICE_PROPERTIES_H <freetype/internal/services/svprop.h>
749 #define FT_SERVICE_SFNT_H <freetype/internal/services/svsfnt.h>
750 #define FT_SERVICE_TRUETYPE_ENGINE_H <freetype/internal/services/svtteng.h>
751 #define FT_SERVICE_TT_CMAP_H <freetype/internal/services/svttcmap.h>
752 #define FT_SERVICE_WINFNT_H <freetype/internal/services/svwinfnt.h>
753 #define FT_SERVICE_FONT_FORMAT_H <freetype/internal/services/svfntfmt.h>
754 #define FT_SERVICE_TRUETYPE_GLYF_H <freetype/internal/services/svttglyf.h>
755
756 /* */
757
758 FT_END_HEADER
759
760 #endif /* FTSERV_H_ */
761
762
763 /* END */
A free Windows-compatible Operating System