ReactOS  0.4.15-dev-1636-gf634010
cidgload.c File Reference
#include <ft2build.h>
#include "cidload.h"
#include "cidgload.h"
#include "ciderrs.h"
Include dependency graph for cidgload.c:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define FT_COMPONENT   trace_cidgload
 

Functions

 cid_load_glyph (T1_Decoder decoder, FT_UInt glyph_index)
 
 cid_slot_load_glyph (FT_GlyphSlot cidglyph, FT_Size cidsize, FT_UInt glyph_index, FT_Int32 load_flags)
 

Macro Definition Documentation

◆ FT_COMPONENT

#define FT_COMPONENT   trace_cidgload

Definition at line 41 of file cidgload.c.

Function Documentation

◆ cid_load_glyph()

cid_load_glyph ( T1_Decoder  decoder,
FT_UInt  glyph_index 
)

Definition at line 45 of file cidgload.c.

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 );
122  FT_FRAME_EXIT();
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  }
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
#define FIXED_TO_INT(x)
Definition: ftcalc.h:406
FT_Int length
Definition: fttypes.h:409
int FT_Error
Definition: fttypes.h:300
FT_Pos y
Definition: ftimage.h:77
FT_Matrix font_matrix
Definition: t1tables.h:352
struct CID_FaceRec_ * CID_Face
Definition: t1types.h:197
unsigned long FT_ULong
Definition: fttypes.h:253
FT_Vector advance
Definition: psaux.h:793
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
FT_Int lenIV
Definition: psaux.h:907
#define FT_HINTING_FREETYPE
Definition: ftdriver.h:345
FT_UInt * subrs_len
Definition: psaux.h:910
#define error(str)
Definition: mkdosfs.c:1605
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
FT_Pos x
Definition: ftimage.h:76
#define TRUE
Definition: types.h:120
FT_GlyphSlot glyph
Definition: psaux.h:784
CFF_SubFont current_subfont
Definition: psaux.h:614
FT_Bool metrics_only
Definition: psaux.h:800
FT_Vector font_offset
Definition: t1tables.h:353
FT_Byte ** code
Definition: t1types.h:133
const FT_Byte * pointer
Definition: fttypes.h:408
return FT_Err_Ok
Definition: ftbbox.c:511
static char memory[1024 *256]
Definition: process.c:116
FT_Int lenIV
Definition: t1tables.h:141
FT_Incremental_GetGlyphDataFunc get_glyph_data
Definition: ftincrem.h:272
FT_BEGIN_HEADER struct PS_DriverRec_ * PS_Driver
#define FT_FACE_DRIVER(x)
Definition: ftobjs.h:634
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
static TfClientId cid
#define FALSE
Definition: types.h:117
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FT_FREE(ptr)
Definition: ftmemory.h:329
#define FT_STREAM_READ_AT(position, buffer, count)
Definition: ftstream.h:502
#define FT_TRACE0(varformat)
Definition: ftdebug.h:157
FT_Int num_subrs
Definition: t1types.h:132
if(!(yy_init))
Definition: macro.lex.yy.c:714
FT_Face face
Definition: psaux.h:783
static void Exit(void)
Definition: sock.c:1331
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:591
T1_BuilderRec builder
Definition: psaux.h:895
FT_Incremental_GetGlyphMetricsFunc get_glyph_metrics
Definition: ftincrem.h:274
FT_Byte ** subrs
Definition: psaux.h:909
FT_Vector left_bearing
Definition: psaux.h:792
struct CID_GlyphSlotRec_ * CID_GlyphSlot
Definition: cidobjs.h:67
unsigned int size
Definition: parse.h:27
Definition: parse.h:22
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
PS_PrivateRec private_dict
Definition: t1tables.h:343
#define FT_FRAME_EXIT()
Definition: ftstream.h:517
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
FT_Matrix font_matrix
Definition: psaux.h:913
FT_Incremental_FreeGlyphDataFunc free_glyph_data
Definition: ftincrem.h:273
#define FT_FACE(x)
Definition: ftobjs.h:630
unsigned int FT_UInt
Definition: fttypes.h:231
#define NULL
Definition: types.h:112
FT_Int num_subrs
Definition: psaux.h:908
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:512
FT_Hash subrs_hash
Definition: psaux.h:911
FT_Vector font_offset
Definition: psaux.h:914
GLfloat GLfloat p
Definition: glext.h:8902
#define INT_TO_FIXED(x)
Definition: ftcalc.h:404
#define ft_memcpy
Definition: ftstdlib.h:82
cid_get_offset(FT_Byte **start, FT_Byte offsize)
Definition: cidload.c:42
const FT_Incremental_FuncsRec * funcs
Definition: ftincrem.h:317
GLenum GLuint GLint GLenum face
Definition: glext.h:7025

Referenced by cid_slot_load_glyph().

◆ cid_slot_load_glyph()

cid_slot_load_glyph ( FT_GlyphSlot  cidglyph,
FT_Size  cidsize,
FT_UInt  glyph_index,
FT_Int32  load_flags 
)

Definition at line 337 of file cidgload.c.

341  {
342  CID_GlyphSlot glyph = (CID_GlyphSlot)cidglyph;
343  FT_Error error;
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 ),
394  cid_load_glyph );
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;
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 =
437  FIXED_TO_INT( decoder.builder.left_bearing.x );
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 )
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  }
#define FIXED_TO_INT(x)
Definition: ftcalc.h:406
int FT_Error
Definition: fttypes.h:300
#define FT_LOAD_VERTICAL_LAYOUT
Definition: freetype.h:3013
FT_Pos y
Definition: ftimage.h:77
struct CID_FaceRec_ * CID_Face
Definition: t1types.h:197
FT_Vector advance
Definition: psaux.h:793
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2933
#define error(str)
Definition: mkdosfs.c:1605
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
FT_Outline * base
Definition: psaux.h:786
FT_Pos x
Definition: ftimage.h:76
#define TRUE
Definition: types.h:120
signed int FT_Int
Definition: fttypes.h:220
FT_Fixed y_scale
Definition: freetype.h:1644
#define free
Definition: debug_ros.c:5
FT_Glyph_Metrics metrics
Definition: freetype.h:1916
FT_Fixed linearHoriAdvance
Definition: freetype.h:1917
#define FT_LOAD_NO_HINTING
Definition: freetype.h:3010
GLdouble n
Definition: glext.h:7729
#define FT_LOAD_NO_RECURSE
Definition: freetype.h:3018
FT_Fixed linearVertAdvance
Definition: freetype.h:1918
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
#define FT_LOAD_NO_SCALE
Definition: freetype.h:3009
FT_Bool no_recurse
Definition: psaux.h:798
FT_Fixed xx
Definition: fttypes.h:387
#define FALSE
Definition: types.h:117
#define FT_THROW(e)
Definition: ftdebug.h:213
FT_Bool scaled
Definition: cidobjs.h:106
FT_Outline_Get_CBox(const FT_Outline *outline, FT_BBox *acbox)
Definition: ftoutln.c:478
FT_Pos yMax
Definition: ftimage.h:118
FT_Outline_Transform(const FT_Outline *outline, const FT_Matrix *matrix)
Definition: ftoutln.c:711
FT_Fixed y_scale
Definition: cidobjs.h:109
FT_Bool glyph_transformed
Definition: ftobjs.h:469
#define FT_OUTLINE_HIGH_PRECISION
Definition: ftimage.h:435
smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_GLYPH_FORMAT_OUTLINE
Definition: ftsmooth.c:416
FT_Pos xMin
Definition: ftimage.h:117
static void Exit(void)
Definition: sock.c:1331
FT_Fixed x_scale
Definition: cidobjs.h:108
FT_Pos xMax
Definition: ftimage.h:118
T1_BuilderRec builder
Definition: psaux.h:895
FT_Vector * vec
Definition: ftbbox.c:448
#define FT_OUTLINE_OWNER
Definition: ftimage.h:428
FT_Vector left_bearing
Definition: psaux.h:792
struct CID_GlyphSlotRec_ * CID_GlyphSlot
Definition: cidobjs.h:67
FT_Size_Metrics metrics
Definition: freetype.h:1677
int flags
Definition: ftimage.h:343
FT_Outline outline
Definition: freetype.h:1927
#define FT_BOOL(x)
Definition: fttypes.h:578
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:509
FxCollectionEntry * cur
void * hints_funcs
Definition: psaux.h:802
FT_Glyph_Format format
Definition: freetype.h:1921
FT_Matrix font_matrix
Definition: psaux.h:913
signed long FT_Fixed
Definition: fttypes.h:288
short n_points
Definition: ftimage.h:337
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
FT_Fixed x_scale
Definition: freetype.h:1643
unsigned int FT_UInt
Definition: fttypes.h:231
FT_Fixed xy
Definition: fttypes.h:387
FT_Pos yMin
Definition: ftimage.h:117
FT_Bool hint
Definition: cidobjs.h:105
FT_UShort y_ppem
Definition: freetype.h:1641
FT_Outline_Translate(const FT_Outline *outline, FT_Pos xOffset, FT_Pos yOffset)
Definition: ftoutln.c:528
FT_Slot_Internal internal
Definition: freetype.h:1940
#define malloc
Definition: debug_ros.c:4
FT_Fixed yx
Definition: fttypes.h:388
FT_Fixed yy
Definition: fttypes.h:388
FT_Vector font_offset
Definition: psaux.h:914
short n_contours
Definition: ftimage.h:336
cid_load_glyph(T1_Decoder decoder, FT_UInt glyph_index)
Definition: cidgload.c:45
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
#define FT_OUTLINE_REVERSE_FILL
Definition: ftimage.h:430
#define FT_LOAD_TARGET_MODE(x)
Definition: freetype.h:3137