ReactOS 0.4.15-dev-7660-g0086d05
cidgload.c
Go to the documentation of this file.
1/***************************************************************************/
2/* */
3/* cidgload.c */
4/* */
5/* CID-keyed Type1 Glyph Loader (body). */
6/* */
7/* Copyright 1996-2018 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#include <ft2build.h>
20#include "cidload.h"
21#include "cidgload.h"
22#include FT_INTERNAL_DEBUG_H
23#include FT_INTERNAL_STREAM_H
24#include FT_OUTLINE_H
25#include FT_INTERNAL_CALC_H
26
27#include FT_INTERNAL_POSTSCRIPT_AUX_H
28#include FT_INTERNAL_CFF_TYPES_H
29#include FT_DRIVER_H
30
31#include "ciderrs.h"
32
33
34 /*************************************************************************/
35 /* */
36 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
37 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
38 /* messages during execution. */
39 /* */
40#undef FT_COMPONENT
41#define FT_COMPONENT trace_cidgload
42
43
46 FT_UInt glyph_index )
47 {
48 CID_Face face = (CID_Face)decoder->builder.face;
49 CID_FaceInfo cid = &face->cid;
50 FT_Byte* p;
51 FT_ULong fd_select;
52 FT_Stream stream = face->cid_stream;
54 FT_Byte* charstring = NULL;
55 FT_Memory memory = face->root.memory;
56 FT_ULong glyph_length = 0;
57 PSAux_Service psaux = (PSAux_Service)face->psaux;
58
59 FT_Bool force_scaling = FALSE;
60
61#ifdef FT_CONFIG_OPTION_INCREMENTAL
63 face->root.internal->incremental_interface;
64#endif
65
66
67 FT_TRACE1(( "cid_load_glyph: glyph index %d\n", glyph_index ));
68
69#ifdef FT_CONFIG_OPTION_INCREMENTAL
70
71 /* For incremental fonts get the character data using */
72 /* the callback function. */
73 if ( inc )
74 {
75 FT_Data glyph_data;
76
77
78 error = inc->funcs->get_glyph_data( inc->object,
79 glyph_index, &glyph_data );
80 if ( error )
81 goto Exit;
82
83 p = (FT_Byte*)glyph_data.pointer;
84 fd_select = cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
85
86 if ( glyph_data.length != 0 )
87 {
88 glyph_length = (FT_ULong)( glyph_data.length - cid->fd_bytes );
89 (void)FT_ALLOC( charstring, glyph_length );
90 if ( !error )
91 ft_memcpy( charstring, glyph_data.pointer + cid->fd_bytes,
92 glyph_length );
93 }
94
95 inc->funcs->free_glyph_data( inc->object, &glyph_data );
96
97 if ( error )
98 goto Exit;
99 }
100
101 else
102
103#endif /* FT_CONFIG_OPTION_INCREMENTAL */
104
105 /* For ordinary fonts read the CID font dictionary index */
106 /* and charstring offset from the CIDMap. */
107 {
108 FT_UInt entry_len = (FT_UInt)( cid->fd_bytes + cid->gd_bytes );
109 FT_ULong off1, off2;
110
111
112 if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
113 glyph_index * entry_len ) ||
114 FT_FRAME_ENTER( 2 * entry_len ) )
115 goto Exit;
116
117 p = (FT_Byte*)stream->cursor;
118 fd_select = cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
119 off1 = cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
120 p += cid->fd_bytes;
121 off2 = cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
123
124 if ( fd_select >= (FT_ULong)cid->num_dicts ||
125 off2 > stream->size ||
126 off1 > off2 )
127 {
128 FT_TRACE0(( "cid_load_glyph: invalid glyph stream offsets\n" ));
129 error = FT_THROW( Invalid_Offset );
130 goto Exit;
131 }
132
133 glyph_length = off2 - off1;
134 if ( glyph_length == 0 )
135 goto Exit;
136 if ( FT_ALLOC( charstring, glyph_length ) )
137 goto Exit;
138 if ( FT_STREAM_READ_AT( cid->data_offset + off1,
139 charstring, glyph_length ) )
140 goto Exit;
141 }
142
143 /* Now set up the subrs array and parse the charstrings. */
144 {
145 CID_FaceDict dict;
146 CID_Subrs cid_subrs = face->subrs + fd_select;
147 FT_UInt cs_offset;
148
149
150 /* Set up subrs */
151 decoder->num_subrs = cid_subrs->num_subrs;
152 decoder->subrs = cid_subrs->code;
153 decoder->subrs_len = 0;
154 decoder->subrs_hash = NULL;
155
156 /* Set up font matrix */
157 dict = cid->font_dicts + fd_select;
158
159 decoder->font_matrix = dict->font_matrix;
160 decoder->font_offset = dict->font_offset;
161 decoder->lenIV = dict->private_dict.lenIV;
162
163 /* Decode the charstring. */
164
165 /* Adjustment for seed bytes. */
166 cs_offset = decoder->lenIV >= 0 ? (FT_UInt)decoder->lenIV : 0;
167 if ( cs_offset > glyph_length )
168 {
169 FT_TRACE0(( "cid_load_glyph: invalid glyph stream offsets\n" ));
170 error = FT_THROW( Invalid_Offset );
171 goto Exit;
172 }
173
174 /* Decrypt only if lenIV >= 0. */
175 if ( decoder->lenIV >= 0 )
176 psaux->t1_decrypt( charstring, glyph_length, 4330 );
177
178 /* choose which renderer to use */
179#ifdef T1_CONFIG_OPTION_OLD_ENGINE
180 if ( ( (PS_Driver)FT_FACE_DRIVER( face ) )->hinting_engine ==
182 decoder->builder.metrics_only )
183 error = psaux->t1_decoder_funcs->parse_charstrings_old(
184 decoder,
185 charstring + cs_offset,
186 glyph_length - cs_offset );
187#else
188 if ( decoder->builder.metrics_only )
189 error = psaux->t1_decoder_funcs->parse_metrics(
190 decoder,
191 charstring + cs_offset,
192 glyph_length - cs_offset );
193#endif
194 else
195 {
196 PS_Decoder psdecoder;
197 CFF_SubFontRec subfont;
198
199
200 psaux->ps_decoder_init( &psdecoder, decoder, TRUE );
201
202 psaux->t1_make_subfont( FT_FACE( face ),
203 &dict->private_dict,
204 &subfont );
205 psdecoder.current_subfont = &subfont;
206
207 error = psaux->t1_decoder_funcs->parse_charstrings(
208 &psdecoder,
209 charstring + cs_offset,
210 glyph_length - cs_offset );
211
212 /* Adobe's engine uses 16.16 numbers everywhere; */
213 /* as a consequence, glyphs larger than 2000ppem get rejected */
214 if ( FT_ERR_EQ( error, Glyph_Too_Big ) )
215 {
216 /* this time, we retry unhinted and scale up the glyph later on */
217 /* (the engine uses and sets the hardcoded value 0x10000 / 64 = */
218 /* 0x400 for both `x_scale' and `y_scale' in this case) */
219 ((CID_GlyphSlot)decoder->builder.glyph)->hint = FALSE;
220
221 force_scaling = TRUE;
222
223 error = psaux->t1_decoder_funcs->parse_charstrings(
224 &psdecoder,
225 charstring + cs_offset,
226 glyph_length - cs_offset );
227 }
228 }
229 }
230
231#ifdef FT_CONFIG_OPTION_INCREMENTAL
232
233 /* Incremental fonts can optionally override the metrics. */
234 if ( !error && inc && inc->funcs->get_glyph_metrics )
235 {
237
238
239 metrics.bearing_x = FIXED_TO_INT( decoder->builder.left_bearing.x );
240 metrics.bearing_y = 0;
241 metrics.advance = FIXED_TO_INT( decoder->builder.advance.x );
242 metrics.advance_v = FIXED_TO_INT( decoder->builder.advance.y );
243
244 error = inc->funcs->get_glyph_metrics( inc->object,
245 glyph_index, FALSE, &metrics );
246
247 decoder->builder.left_bearing.x = INT_TO_FIXED( metrics.bearing_x );
248 decoder->builder.advance.x = INT_TO_FIXED( metrics.advance );
249 decoder->builder.advance.y = INT_TO_FIXED( metrics.advance_v );
250 }
251
252#endif /* FT_CONFIG_OPTION_INCREMENTAL */
253
254 Exit:
255 FT_FREE( charstring );
256
257 ((CID_GlyphSlot)decoder->builder.glyph)->scaled = force_scaling;
258
259 return error;
260 }
261
262
263#if 0
264
265
266 /*************************************************************************/
267 /*************************************************************************/
268 /*************************************************************************/
269 /********** *********/
270 /********** *********/
271 /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/
272 /********** *********/
273 /********** The following code is in charge of computing *********/
274 /********** the maximum advance width of the font. It *********/
275 /********** quickly processes each glyph charstring to *********/
276 /********** extract the value from either a `sbw' or `seac' *********/
277 /********** operator. *********/
278 /********** *********/
279 /*************************************************************************/
280 /*************************************************************************/
281 /*************************************************************************/
282
283
285 cid_face_compute_max_advance( CID_Face face,
286 FT_Int* max_advance )
287 {
289 T1_DecoderRec decoder;
290 FT_Int glyph_index;
291
292 PSAux_Service psaux = (PSAux_Service)face->psaux;
293
294
295 *max_advance = 0;
296
297 /* Initialize load decoder */
298 error = psaux->t1_decoder_funcs->init( &decoder,
299 (FT_Face)face,
300 0, /* size */
301 0, /* glyph slot */
302 0, /* glyph names! XXX */
303 0, /* blend == 0 */
304 0, /* hinting == 0 */
306 if ( error )
307 return error;
308
309 /* TODO: initialize decoder.len_buildchar and decoder.buildchar */
310 /* if we ever support CID-keyed multiple master fonts */
311
312 decoder.builder.metrics_only = 1;
313 decoder.builder.load_points = 0;
314
315 /* for each glyph, parse the glyph charstring and extract */
316 /* the advance width */
317 for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
318 glyph_index++ )
319 {
320 /* now get load the unscaled outline */
321 error = cid_load_glyph( &decoder, glyph_index );
322 /* ignore the error if one occurred - skip to next glyph */
323 }
324
325 *max_advance = FIXED_TO_INT( decoder.builder.advance.x );
326
327 psaux->t1_decoder_funcs->done( &decoder );
328
329 return FT_Err_Ok;
330 }
331
332
333#endif /* 0 */
334
335
337 cid_slot_load_glyph( FT_GlyphSlot cidglyph, /* CID_GlyphSlot */
338 FT_Size cidsize, /* CID_Size */
339 FT_UInt glyph_index,
340 FT_Int32 load_flags )
341 {
342 CID_GlyphSlot glyph = (CID_GlyphSlot)cidglyph;
344#ifdef __REACTOS__
345 T1_DecoderRec *decoder = malloc(sizeof(T1_DecoderRec));
346 if (!decoder) return FT_Err_Out_Of_Memory;
347/* Ugly but it allows us to reduce the diff */
348#define decoder (*decoder)
349 {
350#else
351 T1_DecoderRec decoder;
352#endif
353 CID_Face face = (CID_Face)cidglyph->face;
354 FT_Bool hinting;
355 FT_Bool scaled;
356
357 PSAux_Service psaux = (PSAux_Service)face->psaux;
358 FT_Matrix font_matrix;
359 FT_Vector font_offset;
360 FT_Bool must_finish_decoder = FALSE;
361
362
363 if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
364 {
365 error = FT_THROW( Invalid_Argument );
366 goto Exit;
367 }
368
369 if ( load_flags & FT_LOAD_NO_RECURSE )
370 load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
371
372 glyph->x_scale = cidsize->metrics.x_scale;
373 glyph->y_scale = cidsize->metrics.y_scale;
374
375 cidglyph->outline.n_points = 0;
376 cidglyph->outline.n_contours = 0;
377
378 hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
379 ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
380 scaled = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
381
382 glyph->hint = hinting;
383 glyph->scaled = scaled;
384 cidglyph->format = FT_GLYPH_FORMAT_OUTLINE;
385
386 error = psaux->t1_decoder_funcs->init( &decoder,
387 cidglyph->face,
388 cidsize,
389 cidglyph,
390 0, /* glyph names -- XXX */
391 0, /* blend == 0 */
392 hinting,
393 FT_LOAD_TARGET_MODE( load_flags ),
395 if ( error )
396 goto Exit;
397
398 /* TODO: initialize decoder.len_buildchar and decoder.buildchar */
399 /* if we ever support CID-keyed multiple master fonts */
400
401 must_finish_decoder = TRUE;
402
403 /* set up the decoder */
404 decoder.builder.no_recurse = FT_BOOL(
405 ( ( load_flags & FT_LOAD_NO_RECURSE ) != 0 ) );
406
407 error = cid_load_glyph( &decoder, glyph_index );
408 if ( error )
409 goto Exit;
410
411 /* copy flags back for forced scaling */
412 hinting = glyph->hint;
413 scaled = glyph->scaled;
414
415 font_matrix = decoder.font_matrix;
416 font_offset = decoder.font_offset;
417
418 /* save new glyph tables */
419 psaux->t1_decoder_funcs->done( &decoder );
420
421 must_finish_decoder = FALSE;
422
423 /* now set the metrics -- this is rather simple, as */
424 /* the left side bearing is the xMin, and the top side */
425 /* bearing the yMax */
426 cidglyph->outline.flags &= FT_OUTLINE_OWNER;
427 cidglyph->outline.flags |= FT_OUTLINE_REVERSE_FILL;
428
429 /* for composite glyphs, return only left side bearing and */
430 /* advance width */
431 if ( load_flags & FT_LOAD_NO_RECURSE )
432 {
433 FT_Slot_Internal internal = cidglyph->internal;
434
435
436 cidglyph->metrics.horiBearingX =
438 cidglyph->metrics.horiAdvance =
439 FIXED_TO_INT( decoder.builder.advance.x );
440
441 internal->glyph_matrix = font_matrix;
442 internal->glyph_delta = font_offset;
443 internal->glyph_transformed = 1;
444 }
445 else
446 {
447 FT_BBox cbox;
448 FT_Glyph_Metrics* metrics = &cidglyph->metrics;
449
450
451 /* copy the _unscaled_ advance width */
452 metrics->horiAdvance =
453 FIXED_TO_INT( decoder.builder.advance.x );
454 cidglyph->linearHoriAdvance =
455 FIXED_TO_INT( decoder.builder.advance.x );
456 cidglyph->internal->glyph_transformed = 0;
457
458 /* make up vertical ones */
459 metrics->vertAdvance = ( face->cid.font_bbox.yMax -
460 face->cid.font_bbox.yMin ) >> 16;
461 cidglyph->linearVertAdvance = metrics->vertAdvance;
462
463 cidglyph->format = FT_GLYPH_FORMAT_OUTLINE;
464
465 if ( cidsize->metrics.y_ppem < 24 )
466 cidglyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
467
468 /* apply the font matrix, if any */
469 if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||
470 font_matrix.xy != 0 || font_matrix.yx != 0 )
471 {
472 FT_Outline_Transform( &cidglyph->outline, &font_matrix );
473
474 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,
475 font_matrix.xx );
476 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,
477 font_matrix.yy );
478 }
479
480 if ( font_offset.x || font_offset.y )
481 {
482 FT_Outline_Translate( &cidglyph->outline,
483 font_offset.x,
484 font_offset.y );
485
486 metrics->horiAdvance += font_offset.x;
487 metrics->vertAdvance += font_offset.y;
488 }
489
490 if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || scaled )
491 {
492 /* scale the outline and the metrics */
493 FT_Int n;
494 FT_Outline* cur = decoder.builder.base;
495 FT_Vector* vec = cur->points;
496 FT_Fixed x_scale = glyph->x_scale;
497 FT_Fixed y_scale = glyph->y_scale;
498
499
500 /* First of all, scale the points */
501 if ( !hinting || !decoder.builder.hints_funcs )
502 for ( n = cur->n_points; n > 0; n--, vec++ )
503 {
504 vec->x = FT_MulFix( vec->x, x_scale );
505 vec->y = FT_MulFix( vec->y, y_scale );
506 }
507
508 /* Then scale the metrics */
509 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
510 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
511 }
512
513 /* compute the other metrics */
514 FT_Outline_Get_CBox( &cidglyph->outline, &cbox );
515
516 metrics->width = cbox.xMax - cbox.xMin;
517 metrics->height = cbox.yMax - cbox.yMin;
518
519 metrics->horiBearingX = cbox.xMin;
520 metrics->horiBearingY = cbox.yMax;
521
522 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
523 {
524 /* make up vertical ones */
526 metrics->vertAdvance );
527 }
528 }
529
530 Exit:
531
532 if ( must_finish_decoder )
533 psaux->t1_decoder_funcs->done( &decoder );
534
535#ifdef __REACTOS__
536 free(&decoder);
537#undef decoder
538 }
539#endif
540 return error;
541 }
542
543
544/* END */
ios_base &_STLP_CALL internal(ios_base &__s)
Definition: _ios_base.h:311
cid_slot_load_glyph(FT_GlyphSlot cidglyph, FT_Size cidsize, FT_UInt glyph_index, FT_Int32 load_flags)
Definition: cidgload.c:337
cid_load_glyph(T1_Decoder decoder, FT_UInt glyph_index)
Definition: cidgload.c:45
cid_get_offset(FT_Byte **start, FT_Byte offsize)
Definition: cidload.c:42
struct CID_GlyphSlotRec_ * CID_GlyphSlot
Definition: cidobjs.h:67
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
WORD face[3]
Definition: mesh.c:4747
#define FT_LOAD_VERTICAL_LAYOUT
Definition: freetype.h:3013
#define FT_LOAD_TARGET_MODE(x)
Definition: freetype.h:3137
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
#define FT_LOAD_NO_SCALE
Definition: freetype.h:3009
#define FT_LOAD_NO_RECURSE
Definition: freetype.h:3018
#define FT_LOAD_NO_HINTING
Definition: freetype.h:3010
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:509
FT_Vector * vec
Definition: ftbbox.c:448
return FT_Err_Ok
Definition: ftbbox.c:511
#define FIXED_TO_INT(x)
Definition: ftcalc.h:406
#define INT_TO_FIXED(x)
Definition: ftcalc.h:404
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:533
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:388
#define FT_TRACE0(varformat)
Definition: ftdebug.h:157
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
#define FT_HINTING_FREETYPE
Definition: ftdriver.h:345
#define FT_OUTLINE_HIGH_PRECISION
Definition: ftimage.h:435
#define FT_OUTLINE_OWNER
Definition: ftimage.h:428
#define FT_OUTLINE_REVERSE_FILL
Definition: ftimage.h:430
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
#define FT_FREE(ptr)
Definition: ftmemory.h:329
#define FT_FACE(x)
Definition: ftobjs.h:630
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2933
#define FT_FACE_DRIVER(x)
Definition: ftobjs.h:634
FT_Outline_Translate(const FT_Outline *outline, FT_Pos xOffset, FT_Pos yOffset)
Definition: ftoutln.c:528
FT_Outline_Transform(const FT_Outline *outline, const FT_Matrix *matrix)
Definition: ftoutln.c:711
FT_Outline_Get_CBox(const FT_Outline *outline, FT_BBox *acbox)
Definition: ftoutln.c:478
smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_GLYPH_FORMAT_OUTLINE
Definition: ftsmooth.c:426
#define ft_memcpy
Definition: ftstdlib.h:82
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:512
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
#define FT_FRAME_EXIT()
Definition: ftstream.h:517
#define FT_STREAM_READ_AT(position, buffer, count)
Definition: ftstream.h:502
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:591
signed long FT_Fixed
Definition: fttypes.h:288
int FT_Error
Definition: fttypes.h:300
unsigned int FT_UInt
Definition: fttypes.h:231
#define FT_BOOL(x)
Definition: fttypes.h:578
signed int FT_Int
Definition: fttypes.h:220
FxCollectionEntry * cur
GLdouble n
Definition: glext.h:7729
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
GLfloat GLfloat p
Definition: glext.h:8902
if(dx< 0)
Definition: linetemp.h:194
#define error(str)
Definition: mkdosfs.c:1605
static char memory[1024 *256]
Definition: process.c:116
static TfClientId cid
FT_BEGIN_HEADER struct PS_DriverRec_ * PS_Driver
struct PSAux_ServiceRec_ * PSAux_Service
static void Exit(void)
Definition: sock.c:1330
PS_PrivateRec private_dict
Definition: t1tables.h:343
FT_Matrix font_matrix
Definition: t1tables.h:352
FT_Vector font_offset
Definition: t1tables.h:353
FT_Fixed x_scale
Definition: cidobjs.h:108
FT_Bool hint
Definition: cidobjs.h:105
FT_Fixed y_scale
Definition: cidobjs.h:109
FT_Bool scaled
Definition: cidobjs.h:106
FT_Byte ** code
Definition: t1types.h:133
FT_Int num_subrs
Definition: t1types.h:132
FT_Pos xMin
Definition: ftimage.h:117
FT_Pos yMax
Definition: ftimage.h:118
FT_Pos yMin
Definition: ftimage.h:117
FT_Pos xMax
Definition: ftimage.h:118
const FT_Byte * pointer
Definition: fttypes.h:408
FT_Int length
Definition: fttypes.h:409
FT_Incremental_FreeGlyphDataFunc free_glyph_data
Definition: ftincrem.h:273
FT_Incremental_GetGlyphDataFunc get_glyph_data
Definition: ftincrem.h:272
FT_Incremental_GetGlyphMetricsFunc get_glyph_metrics
Definition: ftincrem.h:274
const FT_Incremental_FuncsRec * funcs
Definition: ftincrem.h:317
FT_Fixed xx
Definition: fttypes.h:387
FT_Fixed yx
Definition: fttypes.h:388
FT_Fixed yy
Definition: fttypes.h:388
FT_Fixed xy
Definition: fttypes.h:387
FT_Pos x
Definition: ftimage.h:76
FT_Pos y
Definition: ftimage.h:77
const T1_Decoder_FuncsRec * t1_decoder_funcs
Definition: psaux.h:1284
CFF_SubFont current_subfont
Definition: psaux.h:614
FT_Int lenIV
Definition: t1tables.h:141
FT_Bool no_recurse
Definition: psaux.h:798
FT_Vector advance
Definition: psaux.h:793
FT_Outline * base
Definition: psaux.h:786
FT_Vector left_bearing
Definition: psaux.h:792
FT_Bool metrics_only
Definition: psaux.h:800
FT_Bool load_points
Definition: psaux.h:797
void * hints_funcs
Definition: psaux.h:802
FT_Matrix font_matrix
Definition: psaux.h:913
T1_BuilderRec builder
Definition: psaux.h:895
FT_Vector font_offset
Definition: psaux.h:914
void(* done)(T1_Decoder decoder)
Definition: psaux.h:870
FT_Error(* init)(T1_Decoder decoder, FT_Face face, FT_Size size, FT_GlyphSlot slot, FT_Byte **glyph_names, PS_Blend blend, FT_Bool hinting, FT_Render_Mode hint_mode, T1_Decoder_Callback callback)
Definition: psaux.h:859
Definition: parse.h:23
unsigned int size
Definition: parse.h:27
struct CID_FaceRec_ * CID_Face
Definition: t1types.h:197