OLD | NEW |
| (Empty) |
1 /***************************************************************************/ | |
2 /* */ | |
3 /* ftobjs.h */ | |
4 /* */ | |
5 /* The FreeType private base classes (specification). */ | |
6 /* */ | |
7 /* Copyright 1996-2006, 2008, 2010, 2012-2013 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 /* */ | |
21 /* This file contains the definition of all internal FreeType classes. */ | |
22 /* */ | |
23 /*************************************************************************/ | |
24 | |
25 | |
26 #ifndef __FTOBJS_H__ | |
27 #define __FTOBJS_H__ | |
28 | |
29 #include "../../ft2build.h" | |
30 #include "../ftrender.h" | |
31 #include "../ftsizes.h" | |
32 #include "../ftlcdfil.h" | |
33 #include "ftmemory.h" | |
34 #include "ftgloadr.h" | |
35 #include "ftdriver.h" | |
36 #include "autohint.h" | |
37 #include "ftserv.h" | |
38 #include "ftpic.h" | |
39 | |
40 #ifdef FT_CONFIG_OPTION_INCREMENTAL | |
41 #include "../ftincrem.h" | |
42 #endif | |
43 | |
44 | |
45 FT_BEGIN_HEADER | |
46 | |
47 | |
48 /*************************************************************************/ | |
49 /* */ | |
50 /* Some generic definitions. */ | |
51 /* */ | |
52 #ifndef TRUE | |
53 #define TRUE 1 | |
54 #endif | |
55 | |
56 #ifndef FALSE | |
57 #define FALSE 0 | |
58 #endif | |
59 | |
60 #ifndef NULL | |
61 #define NULL (void*)0 | |
62 #endif | |
63 | |
64 | |
65 /*************************************************************************/ | |
66 /* */ | |
67 /* The min and max functions missing in C. As usual, be careful not to */ | |
68 /* write things like FT_MIN( a++, b++ ) to avoid side effects. */ | |
69 /* */ | |
70 #define FT_MIN( a, b ) ( (a) < (b) ? (a) : (b) ) | |
71 #define FT_MAX( a, b ) ( (a) > (b) ? (a) : (b) ) | |
72 | |
73 #define FT_ABS( a ) ( (a) < 0 ? -(a) : (a) ) | |
74 | |
75 | |
76 #define FT_PAD_FLOOR( x, n ) ( (x) & ~((n)-1) ) | |
77 #define FT_PAD_ROUND( x, n ) FT_PAD_FLOOR( (x) + ((n)/2), n ) | |
78 #define FT_PAD_CEIL( x, n ) FT_PAD_FLOOR( (x) + ((n)-1), n ) | |
79 | |
80 #define FT_PIX_FLOOR( x ) ( (x) & ~63 ) | |
81 #define FT_PIX_ROUND( x ) FT_PIX_FLOOR( (x) + 32 ) | |
82 #define FT_PIX_CEIL( x ) FT_PIX_FLOOR( (x) + 63 ) | |
83 | |
84 | |
85 /* | |
86 * Return the highest power of 2 that is <= value; this correspond to | |
87 * the highest bit in a given 32-bit value. | |
88 */ | |
89 FT_BASE( FT_UInt32 ) | |
90 ft_highpow2( FT_UInt32 value ); | |
91 | |
92 | |
93 /* | |
94 * character classification functions -- since these are used to parse | |
95 * font files, we must not use those in <ctypes.h> which are | |
96 * locale-dependent | |
97 */ | |
98 #define ft_isdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U ) | |
99 | |
100 #define ft_isxdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U || \ | |
101 ( (unsigned)(x) - 'a' ) < 6U || \ | |
102 ( (unsigned)(x) - 'A' ) < 6U ) | |
103 | |
104 /* the next two macros assume ASCII representation */ | |
105 #define ft_isupper( x ) ( ( (unsigned)(x) - 'A' ) < 26U ) | |
106 #define ft_islower( x ) ( ( (unsigned)(x) - 'a' ) < 26U ) | |
107 | |
108 #define ft_isalpha( x ) ( ft_isupper( x ) || ft_islower( x ) ) | |
109 #define ft_isalnum( x ) ( ft_isdigit( x ) || ft_isalpha( x ) ) | |
110 | |
111 | |
112 /*************************************************************************/ | |
113 /*************************************************************************/ | |
114 /*************************************************************************/ | |
115 /**** ****/ | |
116 /**** ****/ | |
117 /**** C H A R M A P S ****/ | |
118 /**** ****/ | |
119 /**** ****/ | |
120 /*************************************************************************/ | |
121 /*************************************************************************/ | |
122 /*************************************************************************/ | |
123 | |
124 /* handle to internal charmap object */ | |
125 typedef struct FT_CMapRec_* FT_CMap; | |
126 | |
127 /* handle to charmap class structure */ | |
128 typedef const struct FT_CMap_ClassRec_* FT_CMap_Class; | |
129 | |
130 /* internal charmap object structure */ | |
131 typedef struct FT_CMapRec_ | |
132 { | |
133 FT_CharMapRec charmap; | |
134 FT_CMap_Class clazz; | |
135 | |
136 } FT_CMapRec; | |
137 | |
138 /* typecase any pointer to a charmap handle */ | |
139 #define FT_CMAP( x ) ((FT_CMap)( x )) | |
140 | |
141 /* obvious macros */ | |
142 #define FT_CMAP_PLATFORM_ID( x ) FT_CMAP( x )->charmap.platform_id | |
143 #define FT_CMAP_ENCODING_ID( x ) FT_CMAP( x )->charmap.encoding_id | |
144 #define FT_CMAP_ENCODING( x ) FT_CMAP( x )->charmap.encoding | |
145 #define FT_CMAP_FACE( x ) FT_CMAP( x )->charmap.face | |
146 | |
147 | |
148 /* class method definitions */ | |
149 typedef FT_Error | |
150 (*FT_CMap_InitFunc)( FT_CMap cmap, | |
151 FT_Pointer init_data ); | |
152 | |
153 typedef void | |
154 (*FT_CMap_DoneFunc)( FT_CMap cmap ); | |
155 | |
156 typedef FT_UInt | |
157 (*FT_CMap_CharIndexFunc)( FT_CMap cmap, | |
158 FT_UInt32 char_code ); | |
159 | |
160 typedef FT_UInt | |
161 (*FT_CMap_CharNextFunc)( FT_CMap cmap, | |
162 FT_UInt32 *achar_code ); | |
163 | |
164 typedef FT_UInt | |
165 (*FT_CMap_CharVarIndexFunc)( FT_CMap cmap, | |
166 FT_CMap unicode_cmap, | |
167 FT_UInt32 char_code, | |
168 FT_UInt32 variant_selector ); | |
169 | |
170 typedef FT_Bool | |
171 (*FT_CMap_CharVarIsDefaultFunc)( FT_CMap cmap, | |
172 FT_UInt32 char_code, | |
173 FT_UInt32 variant_selector ); | |
174 | |
175 typedef FT_UInt32 * | |
176 (*FT_CMap_VariantListFunc)( FT_CMap cmap, | |
177 FT_Memory mem ); | |
178 | |
179 typedef FT_UInt32 * | |
180 (*FT_CMap_CharVariantListFunc)( FT_CMap cmap, | |
181 FT_Memory mem, | |
182 FT_UInt32 char_code ); | |
183 | |
184 typedef FT_UInt32 * | |
185 (*FT_CMap_VariantCharListFunc)( FT_CMap cmap, | |
186 FT_Memory mem, | |
187 FT_UInt32 variant_selector ); | |
188 | |
189 | |
190 typedef struct FT_CMap_ClassRec_ | |
191 { | |
192 FT_ULong size; | |
193 FT_CMap_InitFunc init; | |
194 FT_CMap_DoneFunc done; | |
195 FT_CMap_CharIndexFunc char_index; | |
196 FT_CMap_CharNextFunc char_next; | |
197 | |
198 /* Subsequent entries are special ones for format 14 -- the variant */ | |
199 /* selector subtable which behaves like no other */ | |
200 | |
201 FT_CMap_CharVarIndexFunc char_var_index; | |
202 FT_CMap_CharVarIsDefaultFunc char_var_default; | |
203 FT_CMap_VariantListFunc variant_list; | |
204 FT_CMap_CharVariantListFunc charvariant_list; | |
205 FT_CMap_VariantCharListFunc variantchar_list; | |
206 | |
207 } FT_CMap_ClassRec; | |
208 | |
209 | |
210 #ifndef FT_CONFIG_OPTION_PIC | |
211 | |
212 #define FT_DECLARE_CMAP_CLASS( class_ ) \ | |
213 FT_CALLBACK_TABLE const FT_CMap_ClassRec class_; | |
214 | |
215 #define FT_DEFINE_CMAP_CLASS( \ | |
216 class_, \ | |
217 size_, \ | |
218 init_, \ | |
219 done_, \ | |
220 char_index_, \ | |
221 char_next_, \ | |
222 char_var_index_, \ | |
223 char_var_default_, \ | |
224 variant_list_, \ | |
225 charvariant_list_, \ | |
226 variantchar_list_ ) \ | |
227 FT_CALLBACK_TABLE_DEF \ | |
228 const FT_CMap_ClassRec class_ = \ | |
229 { \ | |
230 size_, \ | |
231 init_, \ | |
232 done_, \ | |
233 char_index_, \ | |
234 char_next_, \ | |
235 char_var_index_, \ | |
236 char_var_default_, \ | |
237 variant_list_, \ | |
238 charvariant_list_, \ | |
239 variantchar_list_ \ | |
240 }; | |
241 | |
242 #else /* FT_CONFIG_OPTION_PIC */ | |
243 | |
244 #define FT_DECLARE_CMAP_CLASS( class_ ) \ | |
245 void \ | |
246 FT_Init_Class_ ## class_( FT_Library library, \ | |
247 FT_CMap_ClassRec* clazz ); | |
248 | |
249 #define FT_DEFINE_CMAP_CLASS( \ | |
250 class_, \ | |
251 size_, \ | |
252 init_, \ | |
253 done_, \ | |
254 char_index_, \ | |
255 char_next_, \ | |
256 char_var_index_, \ | |
257 char_var_default_, \ | |
258 variant_list_, \ | |
259 charvariant_list_, \ | |
260 variantchar_list_ ) \ | |
261 void \ | |
262 FT_Init_Class_ ## class_( FT_Library library, \ | |
263 FT_CMap_ClassRec* clazz ) \ | |
264 { \ | |
265 FT_UNUSED( library ); \ | |
266 \ | |
267 clazz->size = size_; \ | |
268 clazz->init = init_; \ | |
269 clazz->done = done_; \ | |
270 clazz->char_index = char_index_; \ | |
271 clazz->char_next = char_next_; \ | |
272 clazz->char_var_index = char_var_index_; \ | |
273 clazz->char_var_default = char_var_default_; \ | |
274 clazz->variant_list = variant_list_; \ | |
275 clazz->charvariant_list = charvariant_list_; \ | |
276 clazz->variantchar_list = variantchar_list_; \ | |
277 } | |
278 | |
279 #endif /* FT_CONFIG_OPTION_PIC */ | |
280 | |
281 | |
282 /* create a new charmap and add it to charmap->face */ | |
283 FT_BASE( FT_Error ) | |
284 FT_CMap_New( FT_CMap_Class clazz, | |
285 FT_Pointer init_data, | |
286 FT_CharMap charmap, | |
287 FT_CMap *acmap ); | |
288 | |
289 /* destroy a charmap and remove it from face's list */ | |
290 FT_BASE( void ) | |
291 FT_CMap_Done( FT_CMap cmap ); | |
292 | |
293 | |
294 /*************************************************************************/ | |
295 /* */ | |
296 /* <Struct> */ | |
297 /* FT_Face_InternalRec */ | |
298 /* */ | |
299 /* <Description> */ | |
300 /* This structure contains the internal fields of each FT_Face */ | |
301 /* object. These fields may change between different releases of */ | |
302 /* FreeType. */ | |
303 /* */ | |
304 /* <Fields> */ | |
305 /* max_points :: */ | |
306 /* The maximum number of points used to store the vectorial outline */ | |
307 /* of any glyph in this face. If this value cannot be known in */ | |
308 /* advance, or if the face isn't scalable, this should be set to 0. */ | |
309 /* Only relevant for scalable formats. */ | |
310 /* */ | |
311 /* max_contours :: */ | |
312 /* The maximum number of contours used to store the vectorial */ | |
313 /* outline of any glyph in this face. If this value cannot be */ | |
314 /* known in advance, or if the face isn't scalable, this should be */ | |
315 /* set to 0. Only relevant for scalable formats. */ | |
316 /* */ | |
317 /* transform_matrix :: */ | |
318 /* A 2x2 matrix of 16.16 coefficients used to transform glyph */ | |
319 /* outlines after they are loaded from the font. Only used by the */ | |
320 /* convenience functions. */ | |
321 /* */ | |
322 /* transform_delta :: */ | |
323 /* A translation vector used to transform glyph outlines after they */ | |
324 /* are loaded from the font. Only used by the convenience */ | |
325 /* functions. */ | |
326 /* */ | |
327 /* transform_flags :: */ | |
328 /* Some flags used to classify the transform. Only used by the */ | |
329 /* convenience functions. */ | |
330 /* */ | |
331 /* services :: */ | |
332 /* A cache for frequently used services. It should be only */ | |
333 /* accessed with the macro `FT_FACE_LOOKUP_SERVICE'. */ | |
334 /* */ | |
335 /* incremental_interface :: */ | |
336 /* If non-null, the interface through which glyph data and metrics */ | |
337 /* are loaded incrementally for faces that do not provide all of */ | |
338 /* this data when first opened. This field exists only if */ | |
339 /* @FT_CONFIG_OPTION_INCREMENTAL is defined. */ | |
340 /* */ | |
341 /* ignore_unpatented_hinter :: */ | |
342 /* This boolean flag instructs the glyph loader to ignore the */ | |
343 /* native font hinter, if one is found. This is exclusively used */ | |
344 /* in the case when the unpatented hinter is compiled within the */ | |
345 /* library. */ | |
346 /* */ | |
347 /* refcount :: */ | |
348 /* A counter initialized to~1 at the time an @FT_Face structure is */ | |
349 /* created. @FT_Reference_Face increments this counter, and */ | |
350 /* @FT_Done_Face only destroys a face if the counter is~1, */ | |
351 /* otherwise it simply decrements it. */ | |
352 /* */ | |
353 typedef struct FT_Face_InternalRec_ | |
354 { | |
355 FT_Matrix transform_matrix; | |
356 FT_Vector transform_delta; | |
357 FT_Int transform_flags; | |
358 | |
359 FT_ServiceCacheRec services; | |
360 | |
361 #ifdef FT_CONFIG_OPTION_INCREMENTAL | |
362 FT_Incremental_InterfaceRec* incremental_interface; | |
363 #endif | |
364 | |
365 FT_Bool ignore_unpatented_hinter; | |
366 FT_Int refcount; | |
367 | |
368 } FT_Face_InternalRec; | |
369 | |
370 | |
371 /*************************************************************************/ | |
372 /* */ | |
373 /* <Struct> */ | |
374 /* FT_Slot_InternalRec */ | |
375 /* */ | |
376 /* <Description> */ | |
377 /* This structure contains the internal fields of each FT_GlyphSlot */ | |
378 /* object. These fields may change between different releases of */ | |
379 /* FreeType. */ | |
380 /* */ | |
381 /* <Fields> */ | |
382 /* loader :: The glyph loader object used to load outlines */ | |
383 /* into the glyph slot. */ | |
384 /* */ | |
385 /* flags :: Possible values are zero or */ | |
386 /* FT_GLYPH_OWN_BITMAP. The latter indicates */ | |
387 /* that the FT_GlyphSlot structure owns the */ | |
388 /* bitmap buffer. */ | |
389 /* */ | |
390 /* glyph_transformed :: Boolean. Set to TRUE when the loaded glyph */ | |
391 /* must be transformed through a specific */ | |
392 /* font transformation. This is _not_ the same */ | |
393 /* as the face transform set through */ | |
394 /* FT_Set_Transform(). */ | |
395 /* */ | |
396 /* glyph_matrix :: The 2x2 matrix corresponding to the glyph */ | |
397 /* transformation, if necessary. */ | |
398 /* */ | |
399 /* glyph_delta :: The 2d translation vector corresponding to */ | |
400 /* the glyph transformation, if necessary. */ | |
401 /* */ | |
402 /* glyph_hints :: Format-specific glyph hints management. */ | |
403 /* */ | |
404 | |
405 #define FT_GLYPH_OWN_BITMAP 0x1 | |
406 | |
407 typedef struct FT_Slot_InternalRec_ | |
408 { | |
409 FT_GlyphLoader loader; | |
410 FT_UInt flags; | |
411 FT_Bool glyph_transformed; | |
412 FT_Matrix glyph_matrix; | |
413 FT_Vector glyph_delta; | |
414 void* glyph_hints; | |
415 | |
416 } FT_GlyphSlot_InternalRec; | |
417 | |
418 | |
419 #if 0 | |
420 | |
421 /*************************************************************************/ | |
422 /* */ | |
423 /* <Struct> */ | |
424 /* FT_Size_InternalRec */ | |
425 /* */ | |
426 /* <Description> */ | |
427 /* This structure contains the internal fields of each FT_Size */ | |
428 /* object. Currently, it's empty. */ | |
429 /* */ | |
430 /*************************************************************************/ | |
431 | |
432 typedef struct FT_Size_InternalRec_ | |
433 { | |
434 /* empty */ | |
435 | |
436 } FT_Size_InternalRec; | |
437 | |
438 #endif | |
439 | |
440 | |
441 /*************************************************************************/ | |
442 /*************************************************************************/ | |
443 /*************************************************************************/ | |
444 /**** ****/ | |
445 /**** ****/ | |
446 /**** M O D U L E S ****/ | |
447 /**** ****/ | |
448 /**** ****/ | |
449 /*************************************************************************/ | |
450 /*************************************************************************/ | |
451 /*************************************************************************/ | |
452 | |
453 | |
454 /*************************************************************************/ | |
455 /* */ | |
456 /* <Struct> */ | |
457 /* FT_ModuleRec */ | |
458 /* */ | |
459 /* <Description> */ | |
460 /* A module object instance. */ | |
461 /* */ | |
462 /* <Fields> */ | |
463 /* clazz :: A pointer to the module's class. */ | |
464 /* */ | |
465 /* library :: A handle to the parent library object. */ | |
466 /* */ | |
467 /* memory :: A handle to the memory manager. */ | |
468 /* */ | |
469 typedef struct FT_ModuleRec_ | |
470 { | |
471 FT_Module_Class* clazz; | |
472 FT_Library library; | |
473 FT_Memory memory; | |
474 | |
475 } FT_ModuleRec; | |
476 | |
477 | |
478 /* typecast an object to an FT_Module */ | |
479 #define FT_MODULE( x ) ((FT_Module)( x )) | |
480 #define FT_MODULE_CLASS( x ) FT_MODULE( x )->clazz | |
481 #define FT_MODULE_LIBRARY( x ) FT_MODULE( x )->library | |
482 #define FT_MODULE_MEMORY( x ) FT_MODULE( x )->memory | |
483 | |
484 | |
485 #define FT_MODULE_IS_DRIVER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ | |
486 FT_MODULE_FONT_DRIVER ) | |
487 | |
488 #define FT_MODULE_IS_RENDERER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ | |
489 FT_MODULE_RENDERER ) | |
490 | |
491 #define FT_MODULE_IS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ | |
492 FT_MODULE_HINTER ) | |
493 | |
494 #define FT_MODULE_IS_STYLER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ | |
495 FT_MODULE_STYLER ) | |
496 | |
497 #define FT_DRIVER_IS_SCALABLE( x ) ( FT_MODULE_CLASS( x )->module_flags & \ | |
498 FT_MODULE_DRIVER_SCALABLE ) | |
499 | |
500 #define FT_DRIVER_USES_OUTLINES( x ) !( FT_MODULE_CLASS( x )->module_flags & \ | |
501 FT_MODULE_DRIVER_NO_OUTLINES ) | |
502 | |
503 #define FT_DRIVER_HAS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ | |
504 FT_MODULE_DRIVER_HAS_HINTER ) | |
505 | |
506 | |
507 /*************************************************************************/ | |
508 /* */ | |
509 /* <Function> */ | |
510 /* FT_Get_Module_Interface */ | |
511 /* */ | |
512 /* <Description> */ | |
513 /* Finds a module and returns its specific interface as a typeless */ | |
514 /* pointer. */ | |
515 /* */ | |
516 /* <Input> */ | |
517 /* library :: A handle to the library object. */ | |
518 /* */ | |
519 /* module_name :: The module's name (as an ASCII string). */ | |
520 /* */ | |
521 /* <Return> */ | |
522 /* A module-specific interface if available, 0 otherwise. */ | |
523 /* */ | |
524 /* <Note> */ | |
525 /* You should better be familiar with FreeType internals to know */ | |
526 /* which module to look for, and what its interface is :-) */ | |
527 /* */ | |
528 FT_BASE( const void* ) | |
529 FT_Get_Module_Interface( FT_Library library, | |
530 const char* mod_name ); | |
531 | |
532 FT_BASE( FT_Pointer ) | |
533 ft_module_get_service( FT_Module module, | |
534 const char* service_id ); | |
535 | |
536 /* */ | |
537 | |
538 | |
539 /*************************************************************************/ | |
540 /*************************************************************************/ | |
541 /*************************************************************************/ | |
542 /**** ****/ | |
543 /**** ****/ | |
544 /**** F A C E, S I Z E & G L Y P H S L O T O B J E C T S ****/ | |
545 /**** ****/ | |
546 /**** ****/ | |
547 /*************************************************************************/ | |
548 /*************************************************************************/ | |
549 /*************************************************************************/ | |
550 | |
551 /* a few macros used to perform easy typecasts with minimal brain damage */ | |
552 | |
553 #define FT_FACE( x ) ((FT_Face)(x)) | |
554 #define FT_SIZE( x ) ((FT_Size)(x)) | |
555 #define FT_SLOT( x ) ((FT_GlyphSlot)(x)) | |
556 | |
557 #define FT_FACE_DRIVER( x ) FT_FACE( x )->driver | |
558 #define FT_FACE_LIBRARY( x ) FT_FACE_DRIVER( x )->root.library | |
559 #define FT_FACE_MEMORY( x ) FT_FACE( x )->memory | |
560 #define FT_FACE_STREAM( x ) FT_FACE( x )->stream | |
561 | |
562 #define FT_SIZE_FACE( x ) FT_SIZE( x )->face | |
563 #define FT_SLOT_FACE( x ) FT_SLOT( x )->face | |
564 | |
565 #define FT_FACE_SLOT( x ) FT_FACE( x )->glyph | |
566 #define FT_FACE_SIZE( x ) FT_FACE( x )->size | |
567 | |
568 | |
569 /*************************************************************************/ | |
570 /* */ | |
571 /* <Function> */ | |
572 /* FT_New_GlyphSlot */ | |
573 /* */ | |
574 /* <Description> */ | |
575 /* It is sometimes useful to have more than one glyph slot for a */ | |
576 /* given face object. This function is used to create additional */ | |
577 /* slots. All of them are automatically discarded when the face is */ | |
578 /* destroyed. */ | |
579 /* */ | |
580 /* <Input> */ | |
581 /* face :: A handle to a parent face object. */ | |
582 /* */ | |
583 /* <Output> */ | |
584 /* aslot :: A handle to a new glyph slot object. */ | |
585 /* */ | |
586 /* <Return> */ | |
587 /* FreeType error code. 0 means success. */ | |
588 /* */ | |
589 FT_BASE( FT_Error ) | |
590 FT_New_GlyphSlot( FT_Face face, | |
591 FT_GlyphSlot *aslot ); | |
592 | |
593 | |
594 /*************************************************************************/ | |
595 /* */ | |
596 /* <Function> */ | |
597 /* FT_Done_GlyphSlot */ | |
598 /* */ | |
599 /* <Description> */ | |
600 /* Destroys a given glyph slot. Remember however that all slots are */ | |
601 /* automatically destroyed with its parent. Using this function is */ | |
602 /* not always mandatory. */ | |
603 /* */ | |
604 /* <Input> */ | |
605 /* slot :: A handle to a target glyph slot. */ | |
606 /* */ | |
607 FT_BASE( void ) | |
608 FT_Done_GlyphSlot( FT_GlyphSlot slot ); | |
609 | |
610 /* */ | |
611 | |
612 #define FT_REQUEST_WIDTH( req ) \ | |
613 ( (req)->horiResolution \ | |
614 ? (FT_Pos)( (req)->width * (req)->horiResolution + 36 ) / 72 \ | |
615 : (req)->width ) | |
616 | |
617 #define FT_REQUEST_HEIGHT( req ) \ | |
618 ( (req)->vertResolution \ | |
619 ? (FT_Pos)( (req)->height * (req)->vertResolution + 36 ) / 72 \ | |
620 : (req)->height ) | |
621 | |
622 | |
623 /* Set the metrics according to a bitmap strike. */ | |
624 FT_BASE( void ) | |
625 FT_Select_Metrics( FT_Face face, | |
626 FT_ULong strike_index ); | |
627 | |
628 | |
629 /* Set the metrics according to a size request. */ | |
630 FT_BASE( void ) | |
631 FT_Request_Metrics( FT_Face face, | |
632 FT_Size_Request req ); | |
633 | |
634 | |
635 /* Match a size request against `available_sizes'. */ | |
636 FT_BASE( FT_Error ) | |
637 FT_Match_Size( FT_Face face, | |
638 FT_Size_Request req, | |
639 FT_Bool ignore_width, | |
640 FT_ULong* size_index ); | |
641 | |
642 | |
643 /* Use the horizontal metrics to synthesize the vertical metrics. */ | |
644 /* If `advance' is zero, it is also synthesized. */ | |
645 FT_BASE( void ) | |
646 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics, | |
647 FT_Pos advance ); | |
648 | |
649 | |
650 /* Free the bitmap of a given glyphslot when needed (i.e., only when it */ | |
651 /* was allocated with ft_glyphslot_alloc_bitmap). */ | |
652 FT_BASE( void ) | |
653 ft_glyphslot_free_bitmap( FT_GlyphSlot slot ); | |
654 | |
655 | |
656 /* Allocate a new bitmap buffer in a glyph slot. */ | |
657 FT_BASE( FT_Error ) | |
658 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot, | |
659 FT_ULong size ); | |
660 | |
661 | |
662 /* Set the bitmap buffer in a glyph slot to a given pointer. The buffer */ | |
663 /* will not be freed by a later call to ft_glyphslot_free_bitmap. */ | |
664 FT_BASE( void ) | |
665 ft_glyphslot_set_bitmap( FT_GlyphSlot slot, | |
666 FT_Byte* buffer ); | |
667 | |
668 | |
669 /*************************************************************************/ | |
670 /*************************************************************************/ | |
671 /*************************************************************************/ | |
672 /**** ****/ | |
673 /**** ****/ | |
674 /**** R E N D E R E R S ****/ | |
675 /**** ****/ | |
676 /**** ****/ | |
677 /*************************************************************************/ | |
678 /*************************************************************************/ | |
679 /*************************************************************************/ | |
680 | |
681 | |
682 #define FT_RENDERER( x ) ((FT_Renderer)( x )) | |
683 #define FT_GLYPH( x ) ((FT_Glyph)( x )) | |
684 #define FT_BITMAP_GLYPH( x ) ((FT_BitmapGlyph)( x )) | |
685 #define FT_OUTLINE_GLYPH( x ) ((FT_OutlineGlyph)( x )) | |
686 | |
687 | |
688 typedef struct FT_RendererRec_ | |
689 { | |
690 FT_ModuleRec root; | |
691 FT_Renderer_Class* clazz; | |
692 FT_Glyph_Format glyph_format; | |
693 FT_Glyph_Class glyph_class; | |
694 | |
695 FT_Raster raster; | |
696 FT_Raster_Render_Func raster_render; | |
697 FT_Renderer_RenderFunc render; | |
698 | |
699 } FT_RendererRec; | |
700 | |
701 | |
702 /*************************************************************************/ | |
703 /*************************************************************************/ | |
704 /*************************************************************************/ | |
705 /**** ****/ | |
706 /**** ****/ | |
707 /**** F O N T D R I V E R S ****/ | |
708 /**** ****/ | |
709 /**** ****/ | |
710 /*************************************************************************/ | |
711 /*************************************************************************/ | |
712 /*************************************************************************/ | |
713 | |
714 | |
715 /* typecast a module into a driver easily */ | |
716 #define FT_DRIVER( x ) ((FT_Driver)(x)) | |
717 | |
718 /* typecast a module as a driver, and get its driver class */ | |
719 #define FT_DRIVER_CLASS( x ) FT_DRIVER( x )->clazz | |
720 | |
721 | |
722 /*************************************************************************/ | |
723 /* */ | |
724 /* <Struct> */ | |
725 /* FT_DriverRec */ | |
726 /* */ | |
727 /* <Description> */ | |
728 /* The root font driver class. A font driver is responsible for */ | |
729 /* managing and loading font files of a given format. */ | |
730 /* */ | |
731 /* <Fields> */ | |
732 /* root :: Contains the fields of the root module class. */ | |
733 /* */ | |
734 /* clazz :: A pointer to the font driver's class. Note that */ | |
735 /* this is NOT root.clazz. `class' wasn't used */ | |
736 /* as it is a reserved word in C++. */ | |
737 /* */ | |
738 /* faces_list :: The list of faces currently opened by this */ | |
739 /* driver. */ | |
740 /* */ | |
741 /* glyph_loader :: The glyph loader for all faces managed by this */ | |
742 /* driver. This object isn't defined for unscalable */ | |
743 /* formats. */ | |
744 /* */ | |
745 typedef struct FT_DriverRec_ | |
746 { | |
747 FT_ModuleRec root; | |
748 FT_Driver_Class clazz; | |
749 FT_ListRec faces_list; | |
750 FT_GlyphLoader glyph_loader; | |
751 | |
752 } FT_DriverRec; | |
753 | |
754 | |
755 /*************************************************************************/ | |
756 /*************************************************************************/ | |
757 /*************************************************************************/ | |
758 /**** ****/ | |
759 /**** ****/ | |
760 /**** L I B R A R I E S ****/ | |
761 /**** ****/ | |
762 /**** ****/ | |
763 /*************************************************************************/ | |
764 /*************************************************************************/ | |
765 /*************************************************************************/ | |
766 | |
767 | |
768 /* This hook is used by the TrueType debugger. It must be set to an */ | |
769 /* alternate truetype bytecode interpreter function. */ | |
770 #define FT_DEBUG_HOOK_TRUETYPE 0 | |
771 | |
772 | |
773 /* Set this debug hook to a non-null pointer to force unpatented hinting */ | |
774 /* for all faces when both TT_USE_BYTECODE_INTERPRETER and */ | |
775 /* TT_CONFIG_OPTION_UNPATENTED_HINTING are defined. This is only used */ | |
776 /* during debugging. */ | |
777 #define FT_DEBUG_HOOK_UNPATENTED_HINTING 1 | |
778 | |
779 | |
780 typedef void (*FT_Bitmap_LcdFilterFunc)( FT_Bitmap* bitmap, | |
781 FT_Render_Mode render_mode, | |
782 FT_Library library ); | |
783 | |
784 | |
785 /*************************************************************************/ | |
786 /* */ | |
787 /* <Struct> */ | |
788 /* FT_LibraryRec */ | |
789 /* */ | |
790 /* <Description> */ | |
791 /* The FreeType library class. This is the root of all FreeType */ | |
792 /* data. Use FT_New_Library() to create a library object, and */ | |
793 /* FT_Done_Library() to discard it and all child objects. */ | |
794 /* */ | |
795 /* <Fields> */ | |
796 /* memory :: The library's memory object. Manages memory */ | |
797 /* allocation. */ | |
798 /* */ | |
799 /* version_major :: The major version number of the library. */ | |
800 /* */ | |
801 /* version_minor :: The minor version number of the library. */ | |
802 /* */ | |
803 /* version_patch :: The current patch level of the library. */ | |
804 /* */ | |
805 /* num_modules :: The number of modules currently registered */ | |
806 /* within this library. This is set to 0 for new */ | |
807 /* libraries. New modules are added through the */ | |
808 /* FT_Add_Module() API function. */ | |
809 /* */ | |
810 /* modules :: A table used to store handles to the currently */ | |
811 /* registered modules. Note that each font driver */ | |
812 /* contains a list of its opened faces. */ | |
813 /* */ | |
814 /* renderers :: The list of renderers currently registered */ | |
815 /* within the library. */ | |
816 /* */ | |
817 /* cur_renderer :: The current outline renderer. This is a */ | |
818 /* shortcut used to avoid parsing the list on */ | |
819 /* each call to FT_Outline_Render(). It is a */ | |
820 /* handle to the current renderer for the */ | |
821 /* FT_GLYPH_FORMAT_OUTLINE format. */ | |
822 /* */ | |
823 /* auto_hinter :: XXX */ | |
824 /* */ | |
825 /* raster_pool :: The raster object's render pool. This can */ | |
826 /* ideally be changed dynamically at run-time. */ | |
827 /* */ | |
828 /* raster_pool_size :: The size of the render pool in bytes. */ | |
829 /* */ | |
830 /* debug_hooks :: XXX */ | |
831 /* */ | |
832 /* lcd_filter :: If subpixel rendering is activated, the */ | |
833 /* selected LCD filter mode. */ | |
834 /* */ | |
835 /* lcd_extra :: If subpixel rendering is activated, the number */ | |
836 /* of extra pixels needed for the LCD filter. */ | |
837 /* */ | |
838 /* lcd_weights :: If subpixel rendering is activated, the LCD */ | |
839 /* filter weights, if any. */ | |
840 /* */ | |
841 /* lcd_filter_func :: If subpixel rendering is activated, the LCD */ | |
842 /* filtering callback function. */ | |
843 /* */ | |
844 /* pic_container :: Contains global structs and tables, instead */ | |
845 /* of defining them globallly. */ | |
846 /* */ | |
847 /* refcount :: A counter initialized to~1 at the time an */ | |
848 /* @FT_Library structure is created. */ | |
849 /* @FT_Reference_Library increments this counter, */ | |
850 /* and @FT_Done_Library only destroys a library */ | |
851 /* if the counter is~1, otherwise it simply */ | |
852 /* decrements it. */ | |
853 /* */ | |
854 typedef struct FT_LibraryRec_ | |
855 { | |
856 FT_Memory memory; /* library's memory manager */ | |
857 | |
858 FT_Int version_major; | |
859 FT_Int version_minor; | |
860 FT_Int version_patch; | |
861 | |
862 FT_UInt num_modules; | |
863 FT_Module modules[FT_MAX_MODULES]; /* module objects */ | |
864 | |
865 FT_ListRec renderers; /* list of renderers */ | |
866 FT_Renderer cur_renderer; /* current outline renderer */ | |
867 FT_Module auto_hinter; | |
868 | |
869 FT_Byte* raster_pool; /* scan-line conversion */ | |
870 /* render pool */ | |
871 FT_ULong raster_pool_size; /* size of render pool in bytes */ | |
872 | |
873 FT_DebugHook_Func debug_hooks[4]; | |
874 | |
875 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING | |
876 FT_LcdFilter lcd_filter; | |
877 FT_Int lcd_extra; /* number of extra pixels */ | |
878 FT_Byte lcd_weights[7]; /* filter weights, if any */ | |
879 FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */ | |
880 #endif | |
881 | |
882 #ifdef FT_CONFIG_OPTION_PIC | |
883 FT_PIC_Container pic_container; | |
884 #endif | |
885 | |
886 FT_Int refcount; | |
887 | |
888 } FT_LibraryRec; | |
889 | |
890 | |
891 FT_BASE( FT_Renderer ) | |
892 FT_Lookup_Renderer( FT_Library library, | |
893 FT_Glyph_Format format, | |
894 FT_ListNode* node ); | |
895 | |
896 FT_BASE( FT_Error ) | |
897 FT_Render_Glyph_Internal( FT_Library library, | |
898 FT_GlyphSlot slot, | |
899 FT_Render_Mode render_mode ); | |
900 | |
901 typedef const char* | |
902 (*FT_Face_GetPostscriptNameFunc)( FT_Face face ); | |
903 | |
904 typedef FT_Error | |
905 (*FT_Face_GetGlyphNameFunc)( FT_Face face, | |
906 FT_UInt glyph_index, | |
907 FT_Pointer buffer, | |
908 FT_UInt buffer_max ); | |
909 | |
910 typedef FT_UInt | |
911 (*FT_Face_GetGlyphNameIndexFunc)( FT_Face face, | |
912 FT_String* glyph_name ); | |
913 | |
914 | |
915 #ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM | |
916 | |
917 /*************************************************************************/ | |
918 /* */ | |
919 /* <Function> */ | |
920 /* FT_New_Memory */ | |
921 /* */ | |
922 /* <Description> */ | |
923 /* Creates a new memory object. */ | |
924 /* */ | |
925 /* <Return> */ | |
926 /* A pointer to the new memory object. 0 in case of error. */ | |
927 /* */ | |
928 FT_BASE( FT_Memory ) | |
929 FT_New_Memory( void ); | |
930 | |
931 | |
932 /*************************************************************************/ | |
933 /* */ | |
934 /* <Function> */ | |
935 /* FT_Done_Memory */ | |
936 /* */ | |
937 /* <Description> */ | |
938 /* Discards memory manager. */ | |
939 /* */ | |
940 /* <Input> */ | |
941 /* memory :: A handle to the memory manager. */ | |
942 /* */ | |
943 FT_BASE( void ) | |
944 FT_Done_Memory( FT_Memory memory ); | |
945 | |
946 #endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */ | |
947 | |
948 | |
949 /* Define default raster's interface. The default raster is located in */ | |
950 /* `src/base/ftraster.c'. */ | |
951 /* */ | |
952 /* Client applications can register new rasters through the */ | |
953 /* FT_Set_Raster() API. */ | |
954 | |
955 #ifndef FT_NO_DEFAULT_RASTER | |
956 FT_EXPORT_VAR( FT_Raster_Funcs ) ft_default_raster; | |
957 #endif | |
958 | |
959 | |
960 /*************************************************************************/ | |
961 /*************************************************************************/ | |
962 /*************************************************************************/ | |
963 /**** ****/ | |
964 /**** ****/ | |
965 /**** P I C S U P P O R T ****/ | |
966 /**** ****/ | |
967 /**** ****/ | |
968 /*************************************************************************/ | |
969 /*************************************************************************/ | |
970 /*************************************************************************/ | |
971 | |
972 | |
973 /* PIC support macros for ftimage.h */ | |
974 | |
975 | |
976 /*************************************************************************/ | |
977 /* */ | |
978 /* <Macro> */ | |
979 /* FT_DEFINE_OUTLINE_FUNCS */ | |
980 /* */ | |
981 /* <Description> */ | |
982 /* Used to initialize an instance of FT_Outline_Funcs struct. */ | |
983 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */ | |
984 /* be called with a pre-allocated structure to be filled. */ | |
985 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ | |
986 /* allocated in the global scope (or the scope where the macro */ | |
987 /* is used). */ | |
988 /* */ | |
989 #ifndef FT_CONFIG_OPTION_PIC | |
990 | |
991 #define FT_DEFINE_OUTLINE_FUNCS( \ | |
992 class_, \ | |
993 move_to_, \ | |
994 line_to_, \ | |
995 conic_to_, \ | |
996 cubic_to_, \ | |
997 shift_, \ | |
998 delta_ ) \ | |
999 static const FT_Outline_Funcs class_ = \ | |
1000 { \ | |
1001 move_to_, \ | |
1002 line_to_, \ | |
1003 conic_to_, \ | |
1004 cubic_to_, \ | |
1005 shift_, \ | |
1006 delta_ \ | |
1007 }; | |
1008 | |
1009 #else /* FT_CONFIG_OPTION_PIC */ | |
1010 | |
1011 #define FT_DEFINE_OUTLINE_FUNCS( \ | |
1012 class_, \ | |
1013 move_to_, \ | |
1014 line_to_, \ | |
1015 conic_to_, \ | |
1016 cubic_to_, \ | |
1017 shift_, \ | |
1018 delta_ ) \ | |
1019 static FT_Error \ | |
1020 Init_Class_ ## class_( FT_Outline_Funcs* clazz ) \ | |
1021 { \ | |
1022 clazz->move_to = move_to_; \ | |
1023 clazz->line_to = line_to_; \ | |
1024 clazz->conic_to = conic_to_; \ | |
1025 clazz->cubic_to = cubic_to_; \ | |
1026 clazz->shift = shift_; \ | |
1027 clazz->delta = delta_; \ | |
1028 \ | |
1029 return FT_Err_Ok; \ | |
1030 } | |
1031 | |
1032 #endif /* FT_CONFIG_OPTION_PIC */ | |
1033 | |
1034 | |
1035 /*************************************************************************/ | |
1036 /* */ | |
1037 /* <Macro> */ | |
1038 /* FT_DEFINE_RASTER_FUNCS */ | |
1039 /* */ | |
1040 /* <Description> */ | |
1041 /* Used to initialize an instance of FT_Raster_Funcs struct. */ | |
1042 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */ | |
1043 /* be called with a pre-allocated structure to be filled. */ | |
1044 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ | |
1045 /* allocated in the global scope (or the scope where the macro */ | |
1046 /* is used). */ | |
1047 /* */ | |
1048 #ifndef FT_CONFIG_OPTION_PIC | |
1049 | |
1050 #define FT_DEFINE_RASTER_FUNCS( \ | |
1051 class_, \ | |
1052 glyph_format_, \ | |
1053 raster_new_, \ | |
1054 raster_reset_, \ | |
1055 raster_set_mode_, \ | |
1056 raster_render_, \ | |
1057 raster_done_ ) \ | |
1058 const FT_Raster_Funcs class_ = \ | |
1059 { \ | |
1060 glyph_format_, \ | |
1061 raster_new_, \ | |
1062 raster_reset_, \ | |
1063 raster_set_mode_, \ | |
1064 raster_render_, \ | |
1065 raster_done_ \ | |
1066 }; | |
1067 | |
1068 #else /* FT_CONFIG_OPTION_PIC */ | |
1069 | |
1070 #define FT_DEFINE_RASTER_FUNCS( \ | |
1071 class_, \ | |
1072 glyph_format_, \ | |
1073 raster_new_, \ | |
1074 raster_reset_, \ | |
1075 raster_set_mode_, \ | |
1076 raster_render_, \ | |
1077 raster_done_ ) \ | |
1078 void \ | |
1079 FT_Init_Class_ ## class_( FT_Raster_Funcs* clazz ) \ | |
1080 { \ | |
1081 clazz->glyph_format = glyph_format_; \ | |
1082 clazz->raster_new = raster_new_; \ | |
1083 clazz->raster_reset = raster_reset_; \ | |
1084 clazz->raster_set_mode = raster_set_mode_; \ | |
1085 clazz->raster_render = raster_render_; \ | |
1086 clazz->raster_done = raster_done_; \ | |
1087 } | |
1088 | |
1089 #endif /* FT_CONFIG_OPTION_PIC */ | |
1090 | |
1091 | |
1092 /* PIC support macros for ftrender.h */ | |
1093 | |
1094 | |
1095 /*************************************************************************/ | |
1096 /* */ | |
1097 /* <Macro> */ | |
1098 /* FT_DEFINE_GLYPH */ | |
1099 /* */ | |
1100 /* <Description> */ | |
1101 /* Used to initialize an instance of FT_Glyph_Class struct. */ | |
1102 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */ | |
1103 /* be called with a pre-allocated stcture to be filled. */ | |
1104 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ | |
1105 /* allocated in the global scope (or the scope where the macro */ | |
1106 /* is used). */ | |
1107 /* */ | |
1108 #ifndef FT_CONFIG_OPTION_PIC | |
1109 | |
1110 #define FT_DEFINE_GLYPH( \ | |
1111 class_, \ | |
1112 size_, \ | |
1113 format_, \ | |
1114 init_, \ | |
1115 done_, \ | |
1116 copy_, \ | |
1117 transform_, \ | |
1118 bbox_, \ | |
1119 prepare_ ) \ | |
1120 FT_CALLBACK_TABLE_DEF \ | |
1121 const FT_Glyph_Class class_ = \ | |
1122 { \ | |
1123 size_, \ | |
1124 format_, \ | |
1125 init_, \ | |
1126 done_, \ | |
1127 copy_, \ | |
1128 transform_, \ | |
1129 bbox_, \ | |
1130 prepare_ \ | |
1131 }; | |
1132 | |
1133 #else /* FT_CONFIG_OPTION_PIC */ | |
1134 | |
1135 #define FT_DEFINE_GLYPH( \ | |
1136 class_, \ | |
1137 size_, \ | |
1138 format_, \ | |
1139 init_, \ | |
1140 done_, \ | |
1141 copy_, \ | |
1142 transform_, \ | |
1143 bbox_, \ | |
1144 prepare_ ) \ | |
1145 void \ | |
1146 FT_Init_Class_ ## class_( FT_Glyph_Class* clazz ) \ | |
1147 { \ | |
1148 clazz->glyph_size = size_; \ | |
1149 clazz->glyph_format = format_; \ | |
1150 clazz->glyph_init = init_; \ | |
1151 clazz->glyph_done = done_; \ | |
1152 clazz->glyph_copy = copy_; \ | |
1153 clazz->glyph_transform = transform_; \ | |
1154 clazz->glyph_bbox = bbox_; \ | |
1155 clazz->glyph_prepare = prepare_; \ | |
1156 } | |
1157 | |
1158 #endif /* FT_CONFIG_OPTION_PIC */ | |
1159 | |
1160 | |
1161 /*************************************************************************/ | |
1162 /* */ | |
1163 /* <Macro> */ | |
1164 /* FT_DECLARE_RENDERER */ | |
1165 /* */ | |
1166 /* <Description> */ | |
1167 /* Used to create a forward declaration of a */ | |
1168 /* FT_Renderer_Class struct instance. */ | |
1169 /* */ | |
1170 /* <Macro> */ | |
1171 /* FT_DEFINE_RENDERER */ | |
1172 /* */ | |
1173 /* <Description> */ | |
1174 /* Used to initialize an instance of FT_Renderer_Class struct. */ | |
1175 /* */ | |
1176 /* When FT_CONFIG_OPTION_PIC is defined a `create' funtion will need */ | |
1177 /* to be called with a pointer where the allocated structure is */ | |
1178 /* returned. And when it is no longer needed a `destroy' function */ | |
1179 /* needs to be called to release that allocation. */ | |
1180 /* `fcinit.c' (ft_create_default_module_classes) already contains */ | |
1181 /* a mechanism to call these functions for the default modules */ | |
1182 /* described in `ftmodule.h'. */ | |
1183 /* */ | |
1184 /* Notice that the created `create' and `destroy' functions call */ | |
1185 /* `pic_init' and `pic_free' to allow you to manually allocate and */ | |
1186 /* initialize any additional global data, like a module specific */ | |
1187 /* interface, and put them in the global pic container defined in */ | |
1188 /* `ftpic.h'. If you don't need them just implement the functions as */ | |
1189 /* empty to resolve the link error. Also the `pic_init' and */ | |
1190 /* `pic_free' functions should be declared in `pic.h', to be referred */ | |
1191 /* by the renderer definition calling `FT_DEFINE_RENDERER' in the */ | |
1192 /* following. */ | |
1193 /* */ | |
1194 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ | |
1195 /* allocated in the global scope (or the scope where the macro */ | |
1196 /* is used). */ | |
1197 /* */ | |
1198 #ifndef FT_CONFIG_OPTION_PIC | |
1199 | |
1200 #define FT_DECLARE_RENDERER( class_ ) \ | |
1201 FT_EXPORT_VAR( const FT_Renderer_Class ) class_; | |
1202 | |
1203 #define FT_DEFINE_RENDERER( \ | |
1204 class_, \ | |
1205 flags_, \ | |
1206 size_, \ | |
1207 name_, \ | |
1208 version_, \ | |
1209 requires_, \ | |
1210 interface_, \ | |
1211 init_, \ | |
1212 done_, \ | |
1213 get_interface_, \ | |
1214 glyph_format_, \ | |
1215 render_glyph_, \ | |
1216 transform_glyph_, \ | |
1217 get_glyph_cbox_, \ | |
1218 set_mode_, \ | |
1219 raster_class_ ) \ | |
1220 FT_CALLBACK_TABLE_DEF \ | |
1221 const FT_Renderer_Class class_ = \ | |
1222 { \ | |
1223 FT_DEFINE_ROOT_MODULE( flags_, \ | |
1224 size_, \ | |
1225 name_, \ | |
1226 version_, \ | |
1227 requires_, \ | |
1228 interface_, \ | |
1229 init_, \ | |
1230 done_, \ | |
1231 get_interface_ ) \ | |
1232 glyph_format_, \ | |
1233 \ | |
1234 render_glyph_, \ | |
1235 transform_glyph_, \ | |
1236 get_glyph_cbox_, \ | |
1237 set_mode_, \ | |
1238 \ | |
1239 raster_class_ \ | |
1240 }; | |
1241 | |
1242 #else /* FT_CONFIG_OPTION_PIC */ | |
1243 | |
1244 #define FT_DECLARE_RENDERER( class_ ) FT_DECLARE_MODULE( class_ ) | |
1245 | |
1246 #define FT_DEFINE_RENDERER( \ | |
1247 class_, \ | |
1248 flags_, \ | |
1249 size_, \ | |
1250 name_, \ | |
1251 version_, \ | |
1252 requires_, \ | |
1253 interface_, \ | |
1254 init_, \ | |
1255 done_, \ | |
1256 get_interface_, \ | |
1257 glyph_format_, \ | |
1258 render_glyph_, \ | |
1259 transform_glyph_, \ | |
1260 get_glyph_cbox_, \ | |
1261 set_mode_, \ | |
1262 raster_class_ ) \ | |
1263 void \ | |
1264 FT_Destroy_Class_ ## class_( FT_Library library, \ | |
1265 FT_Module_Class* clazz ) \ | |
1266 { \ | |
1267 FT_Renderer_Class* rclazz = (FT_Renderer_Class*)clazz; \ | |
1268 FT_Memory memory = library->memory; \ | |
1269 \ | |
1270 \ | |
1271 class_ ## _pic_free( library ); \ | |
1272 if ( rclazz ) \ | |
1273 FT_FREE( rclazz ); \ | |
1274 } \ | |
1275 \ | |
1276 \ | |
1277 FT_Error \ | |
1278 FT_Create_Class_ ## class_( FT_Library library, \ | |
1279 FT_Module_Class** output_class ) \ | |
1280 { \ | |
1281 FT_Renderer_Class* clazz = NULL; \ | |
1282 FT_Error error; \ | |
1283 FT_Memory memory = library->memory; \ | |
1284 \ | |
1285 \ | |
1286 if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \ | |
1287 return error; \ | |
1288 \ | |
1289 error = class_ ## _pic_init( library ); \ | |
1290 if ( error ) \ | |
1291 { \ | |
1292 FT_FREE( clazz ); \ | |
1293 return error; \ | |
1294 } \ | |
1295 \ | |
1296 FT_DEFINE_ROOT_MODULE( flags_, \ | |
1297 size_, \ | |
1298 name_, \ | |
1299 version_, \ | |
1300 requires_, \ | |
1301 interface_, \ | |
1302 init_, \ | |
1303 done_, \ | |
1304 get_interface_ ) \ | |
1305 \ | |
1306 clazz->glyph_format = glyph_format_; \ | |
1307 \ | |
1308 clazz->render_glyph = render_glyph_; \ | |
1309 clazz->transform_glyph = transform_glyph_; \ | |
1310 clazz->get_glyph_cbox = get_glyph_cbox_; \ | |
1311 clazz->set_mode = set_mode_; \ | |
1312 \ | |
1313 clazz->raster_class = raster_class_; \ | |
1314 \ | |
1315 *output_class = (FT_Module_Class*)clazz; \ | |
1316 \ | |
1317 return FT_Err_Ok; \ | |
1318 } | |
1319 | |
1320 #endif /* FT_CONFIG_OPTION_PIC */ | |
1321 | |
1322 | |
1323 /* PIC support macros for ftmodapi.h **/ | |
1324 | |
1325 | |
1326 #ifdef FT_CONFIG_OPTION_PIC | |
1327 | |
1328 /*************************************************************************/ | |
1329 /* */ | |
1330 /* <FuncType> */ | |
1331 /* FT_Module_Creator */ | |
1332 /* */ | |
1333 /* <Description> */ | |
1334 /* A function used to create (allocate) a new module class object. */ | |
1335 /* The object's members are initialized, but the module itself is */ | |
1336 /* not. */ | |
1337 /* */ | |
1338 /* <Input> */ | |
1339 /* memory :: A handle to the memory manager. */ | |
1340 /* output_class :: Initialized with the newly allocated class. */ | |
1341 /* */ | |
1342 typedef FT_Error | |
1343 (*FT_Module_Creator)( FT_Memory memory, | |
1344 FT_Module_Class** output_class ); | |
1345 | |
1346 /*************************************************************************/ | |
1347 /* */ | |
1348 /* <FuncType> */ | |
1349 /* FT_Module_Destroyer */ | |
1350 /* */ | |
1351 /* <Description> */ | |
1352 /* A function used to destroy (deallocate) a module class object. */ | |
1353 /* */ | |
1354 /* <Input> */ | |
1355 /* memory :: A handle to the memory manager. */ | |
1356 /* clazz :: Module class to destroy. */ | |
1357 /* */ | |
1358 typedef void | |
1359 (*FT_Module_Destroyer)( FT_Memory memory, | |
1360 FT_Module_Class* clazz ); | |
1361 | |
1362 #endif | |
1363 | |
1364 | |
1365 /*************************************************************************/ | |
1366 /* */ | |
1367 /* <Macro> */ | |
1368 /* FT_DECLARE_MODULE */ | |
1369 /* */ | |
1370 /* <Description> */ | |
1371 /* Used to create a forward declaration of a */ | |
1372 /* FT_Module_Class struct instance. */ | |
1373 /* */ | |
1374 /* <Macro> */ | |
1375 /* FT_DEFINE_MODULE */ | |
1376 /* */ | |
1377 /* <Description> */ | |
1378 /* Used to initialize an instance of an FT_Module_Class struct. */ | |
1379 /* */ | |
1380 /* When FT_CONFIG_OPTION_PIC is defined a `create' funtion needs to */ | |
1381 /* be called with a pointer where the allocated structure is */ | |
1382 /* returned. And when it is no longer needed a `destroy' function */ | |
1383 /* needs to be called to release that allocation. */ | |
1384 /* `fcinit.c' (ft_create_default_module_classes) already contains */ | |
1385 /* a mechanism to call these functions for the default modules */ | |
1386 /* described in `ftmodule.h'. */ | |
1387 /* */ | |
1388 /* Notice that the created `create' and `destroy' functions call */ | |
1389 /* `pic_init' and `pic_free' to allow you to manually allocate and */ | |
1390 /* initialize any additional global data, like a module specific */ | |
1391 /* interface, and put them in the global pic container defined in */ | |
1392 /* `ftpic.h'. If you don't need them just implement the functions as */ | |
1393 /* empty to resolve the link error. Also the `pic_init' and */ | |
1394 /* `pic_free' functions should be declared in `pic.h', to be referred */ | |
1395 /* by the module definition calling `FT_DEFINE_MODULE' in the */ | |
1396 /* following. */ | |
1397 /* */ | |
1398 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ | |
1399 /* allocated in the global scope (or the scope where the macro */ | |
1400 /* is used). */ | |
1401 /* */ | |
1402 /* <Macro> */ | |
1403 /* FT_DEFINE_ROOT_MODULE */ | |
1404 /* */ | |
1405 /* <Description> */ | |
1406 /* Used to initialize an instance of an FT_Module_Class struct inside */ | |
1407 /* another struct that contains it or in a function that initializes */ | |
1408 /* that containing struct. */ | |
1409 /* */ | |
1410 #ifndef FT_CONFIG_OPTION_PIC | |
1411 | |
1412 #define FT_DECLARE_MODULE( class_ ) \ | |
1413 FT_CALLBACK_TABLE \ | |
1414 const FT_Module_Class class_; | |
1415 | |
1416 #define FT_DEFINE_ROOT_MODULE( \ | |
1417 flags_, \ | |
1418 size_, \ | |
1419 name_, \ | |
1420 version_, \ | |
1421 requires_, \ | |
1422 interface_, \ | |
1423 init_, \ | |
1424 done_, \ | |
1425 get_interface_ ) \ | |
1426 { \ | |
1427 flags_, \ | |
1428 size_, \ | |
1429 \ | |
1430 name_, \ | |
1431 version_, \ | |
1432 requires_, \ | |
1433 \ | |
1434 interface_, \ | |
1435 \ | |
1436 init_, \ | |
1437 done_, \ | |
1438 get_interface_, \ | |
1439 }, | |
1440 | |
1441 #define FT_DEFINE_MODULE( \ | |
1442 class_, \ | |
1443 flags_, \ | |
1444 size_, \ | |
1445 name_, \ | |
1446 version_, \ | |
1447 requires_, \ | |
1448 interface_, \ | |
1449 init_, \ | |
1450 done_, \ | |
1451 get_interface_ ) \ | |
1452 FT_CALLBACK_TABLE_DEF \ | |
1453 const FT_Module_Class class_ = \ | |
1454 { \ | |
1455 flags_, \ | |
1456 size_, \ | |
1457 \ | |
1458 name_, \ | |
1459 version_, \ | |
1460 requires_, \ | |
1461 \ | |
1462 interface_, \ | |
1463 \ | |
1464 init_, \ | |
1465 done_, \ | |
1466 get_interface_, \ | |
1467 }; | |
1468 | |
1469 | |
1470 #else /* FT_CONFIG_OPTION_PIC */ | |
1471 | |
1472 #define FT_DECLARE_MODULE( class_ ) \ | |
1473 FT_Error \ | |
1474 FT_Create_Class_ ## class_( FT_Library library, \ | |
1475 FT_Module_Class** output_class ); \ | |
1476 void \ | |
1477 FT_Destroy_Class_ ## class_( FT_Library library, \ | |
1478 FT_Module_Class* clazz ); | |
1479 | |
1480 #define FT_DEFINE_ROOT_MODULE( \ | |
1481 flags_, \ | |
1482 size_, \ | |
1483 name_, \ | |
1484 version_, \ | |
1485 requires_, \ | |
1486 interface_, \ | |
1487 init_, \ | |
1488 done_, \ | |
1489 get_interface_ ) \ | |
1490 clazz->root.module_flags = flags_; \ | |
1491 clazz->root.module_size = size_; \ | |
1492 clazz->root.module_name = name_; \ | |
1493 clazz->root.module_version = version_; \ | |
1494 clazz->root.module_requires = requires_; \ | |
1495 \ | |
1496 clazz->root.module_interface = interface_; \ | |
1497 \ | |
1498 clazz->root.module_init = init_; \ | |
1499 clazz->root.module_done = done_; \ | |
1500 clazz->root.get_interface = get_interface_; | |
1501 | |
1502 #define FT_DEFINE_MODULE( \ | |
1503 class_, \ | |
1504 flags_, \ | |
1505 size_, \ | |
1506 name_, \ | |
1507 version_, \ | |
1508 requires_, \ | |
1509 interface_, \ | |
1510 init_, \ | |
1511 done_, \ | |
1512 get_interface_ ) \ | |
1513 void \ | |
1514 FT_Destroy_Class_ ## class_( FT_Library library, \ | |
1515 FT_Module_Class* clazz ) \ | |
1516 { \ | |
1517 FT_Memory memory = library->memory; \ | |
1518 \ | |
1519 \ | |
1520 class_ ## _pic_free( library ); \ | |
1521 if ( clazz ) \ | |
1522 FT_FREE( clazz ); \ | |
1523 } \ | |
1524 \ | |
1525 \ | |
1526 FT_Error \ | |
1527 FT_Create_Class_ ## class_( FT_Library library, \ | |
1528 FT_Module_Class** output_class ) \ | |
1529 { \ | |
1530 FT_Memory memory = library->memory; \ | |
1531 FT_Module_Class* clazz = NULL; \ | |
1532 FT_Error error; \ | |
1533 \ | |
1534 \ | |
1535 if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \ | |
1536 return error; \ | |
1537 error = class_ ## _pic_init( library ); \ | |
1538 if ( error ) \ | |
1539 { \ | |
1540 FT_FREE( clazz ); \ | |
1541 return error; \ | |
1542 } \ | |
1543 \ | |
1544 clazz->module_flags = flags_; \ | |
1545 clazz->module_size = size_; \ | |
1546 clazz->module_name = name_; \ | |
1547 clazz->module_version = version_; \ | |
1548 clazz->module_requires = requires_; \ | |
1549 \ | |
1550 clazz->module_interface = interface_; \ | |
1551 \ | |
1552 clazz->module_init = init_; \ | |
1553 clazz->module_done = done_; \ | |
1554 clazz->get_interface = get_interface_; \ | |
1555 \ | |
1556 *output_class = clazz; \ | |
1557 \ | |
1558 return FT_Err_Ok; \ | |
1559 } | |
1560 | |
1561 #endif /* FT_CONFIG_OPTION_PIC */ | |
1562 | |
1563 | |
1564 FT_END_HEADER | |
1565 | |
1566 #endif /* __FTOBJS_H__ */ | |
1567 | |
1568 | |
1569 /* END */ | |
OLD | NEW |