自学教程：C++ FT_Outline_Transform函数代码示例

/* transform a given glyph image */staticFT_Error  ft_raster1_transform(FT_Renderer render,                               FT_GlyphSlot slot,                               FT_Matrix    *matrix,                               FT_Vector    *delta){	FT_Error error = FT_Err_Ok;	if(slot->format != render->glyph_format)	{		error = FT_Err_Invalid_Argument;		goto Exit;	}	if(matrix)	{		FT_Outline_Transform(&slot->outline, matrix);	}	if(delta)	{		FT_Outline_Translate(&slot->outline, delta->x, delta->y);	}Exit:	return error;}

  static  void  ft_outline_glyph_transform( FT_OutlineGlyph  glyph,                                    FT_Matrix*       matrix,                                    FT_Vector*       delta )  {    if ( matrix )      FT_Outline_Transform( &glyph->outline, matrix );    if ( delta )      FT_Outline_Translate( &glyph->outline, delta->x, delta->y );  }

static FT_ErrorLoadTrueTypeChar(Font *fnt,                 int idx,                 Boolean hint,                 Boolean quiet){  FT_Error error;  int flags;  flags = FT_LOAD_DEFAULT;  if (hint)    flags |= FT_LOAD_FORCE_AUTOHINT;  error = FT_Load_Glyph(face, idx, flags);  if (!error)  {    if (fnt->efactor != 1.0 || fnt->slant != 0.0 )      FT_Outline_Transform(&face->glyph->outline, &matrix1);    if (fnt->rotate)    {      FT_Outline_Transform(&face->glyph->outline, &matrix2);      error = FT_Outline_Get_BBox(&face->glyph->outline, &bbox); /* we need the non-                                                                    grid-fitted bbox */      if (!error)        FT_Outline_Translate(&face->glyph->outline,                             face->glyph->metrics.vertBearingY - bbox.xMin,                             -fnt->y_offset * ppem * 64);    }  }  if (!error)    error = FT_Outline_Get_BBox(&face->glyph->outline, &bbox);  if (!error)  {    FT_Outline_Get_CBox(&face->glyph->outline, &bbox); /* for the case of BBox != CBox */    SetRasterArea(quiet);  }  return error;}

  ft_outline_glyph_transform( FT_Glyph          outline_glyph,                              const FT_Matrix*  matrix,                              const FT_Vector*  delta )  {    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;    if ( matrix )      FT_Outline_Transform( &glyph->outline, matrix );    if ( delta )      FT_Outline_Translate( &glyph->outline, delta->x, delta->y );  }

void FT_ITALIC(FT_GlyphSlot slot){	FT_Matrix    transform;	FT_Outline*  outline = &slot->outline;	/* only oblique outline glyphs */	if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )	  return;		/* we don't touch the advance width */	/* For italic, simply apply a shear transform, with an angle */	/* of about 12 degrees.                                      */		transform.xx = 0x10000L;	transform.yx = 0x00000L;		transform.xy = 0x03000L;	transform.yy = 0x10000L;		FT_Outline_Transform( outline, &transform );}

const bool GDI2FT_RENDERER::generate_outline_glyph( FT_Glyph* glyph, WORD glyph_index, const FTC_Scaler scaler, FT_F26Dot6 embolden, bool is_italic ) const/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------- */{	FT_Glyph cached_glyph;	{		GDI2FT_MUTEX mutex( GDI2FT_MUTEX::MUTEX_FREETYPE );		if( FTC_ImageCache_LookupScaler( ft_glyph_cache, scaler, FT_LOAD_NO_BITMAP | FT_LOAD_FORCE_AUTOHINT | FT_LOAD_CROP_BITMAP | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH | FT_LOAD_TARGET_LIGHT, glyph_index, &cached_glyph, NULL ) != 0 )			return NULL;	}	if( cached_glyph->format != FT_GLYPH_FORMAT_OUTLINE )		return NULL;	const bool oblique = ( ( context->outline_metrics->otmTextMetrics.tmItalic != 0 ) && !is_italic );	if( oblique || embolden )	{		FT_Glyph_Copy( cached_glyph, glyph );		FT_Outline* glyph_outline = &( reinterpret_cast<FT_OutlineGlyph>( *glyph )->outline );		if( oblique )		{			FT_Matrix oblique_mat = { static_cast<FT_Pos>( 65536 ), static_cast<FT_Pos>( 19661 ), 0, static_cast<FT_Pos>( 65536 ) };			FT_Outline_Transform( glyph_outline, &oblique_mat );		}		if( embolden )			FT_Outline_Embolden( glyph_outline, embolden );		return true;	}	else		*glyph = cached_glyph;	return false;}

static PyObject*Py_Outline_transform(Py_Outline* self, PyObject* args, PyObject* kwds){    double xx, xy, yx, yy;    FT_Matrix matrix;    const char* keywords[] = {"xOffset", "yOffset", NULL};    if (!PyArg_ParseTupleAndKeywords(            args, kwds, "((dd)(dd)):transform", (char **)keywords,            &xx, &xy, &yx, &yy)) {        return NULL;    }    matrix.xx = TO_FT_FIXED(xx);    matrix.xy = TO_FT_FIXED(xy);    matrix.yx = TO_FT_FIXED(yx);    matrix.yy = TO_FT_FIXED(yy);    FT_Outline_Transform(&self->x, &matrix);    Py_RETURN_NONE;};

  /* transform a given glyph image */  static FT_Error  ft_smooth_transform( FT_Renderer       render,                       FT_GlyphSlot      slot,                       const FT_Matrix*  matrix,                       const FT_Vector*  delta )  {    FT_Error  error = FT_Err_Ok;    if ( slot->format != render->glyph_format )    {      error = FT_THROW( Invalid_Argument );      goto Exit;    }    if ( matrix )      FT_Outline_Transform( &slot->outline, matrix );    if ( delta )      FT_Outline_Translate( &slot->outline, delta->x, delta->y );  Exit:    return error;  }

//.........这里部分代码省略.........          {            FT_Outline  dummy = gloader->base.outline;            dummy.points  += num_base_points;            dummy.n_points = (short)num_new_points;            FT_Outline_Translate( &dummy, x, y );          }        }      }      break;    default:      /* we don't support other formats (yet?) */      error = AF_Err_Unimplemented_Feature;    }  Hint_Metrics:    if ( depth == 0 )    {      FT_BBox    bbox;      FT_Vector  vvector;      vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;      vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;      vvector.x = FT_MulFix( vvector.x, metrics->scaler.x_scale );      vvector.y = FT_MulFix( vvector.y, metrics->scaler.y_scale );      /* transform the hinted outline if needed */      if ( loader->transformed )      {        FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );        FT_Vector_Transform( &vvector, &loader->trans_matrix );      }#if 1      /* we must translate our final outline by -pp1.x and compute */      /* the new metrics                                           */      if ( loader->pp1.x )        FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );#endif      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );      bbox.xMin = FT_PIX_FLOOR( bbox.xMin );      bbox.yMin = FT_PIX_FLOOR( bbox.yMin );      bbox.xMax = FT_PIX_CEIL(  bbox.xMax );      bbox.yMax = FT_PIX_CEIL(  bbox.yMax );      slot->metrics.width        = bbox.xMax - bbox.xMin;      slot->metrics.height       = bbox.yMax - bbox.yMin;      slot->metrics.horiBearingX = bbox.xMin;      slot->metrics.horiBearingY = bbox.yMax;      slot->metrics.vertBearingX = FT_PIX_FLOOR( bbox.xMin + vvector.x );      slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );      /* for mono-width fonts (like Andale, Courier, etc.) we need */      /* to keep the original rounded advance width; ditto for     */      /* digits if all have the same advance width                 */#if 0      if ( !FT_IS_FIXED_WIDTH( slot->face ) )        slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;      else        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,                                               x_scale );

static FT_Error Load_Glyph( TTF_Font* font, Uint16 ch, c_glyph* cached, int want ){	FT_Face face;	FT_Error error;	FT_GlyphSlot glyph;	FT_Glyph_Metrics* metrics;	FT_Outline* outline;	if ( !font || !font->face ) {		return FT_Err_Invalid_Handle;	}	face = font->face;	/* Load the glyph */	if ( ! cached->index ) {		cached->index = FT_Get_Char_Index( face, ch );	}	error = FT_Load_Glyph( face, cached->index, FT_LOAD_DEFAULT );	if( error ) {		return error;	}	/* Get our glyph shortcuts */	glyph = face->glyph;	metrics = &glyph->metrics;	outline = &glyph->outline;	/* Get the glyph metrics if desired */	if ( (want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS) ) {		if ( FT_IS_SCALABLE( face ) ) {			/* Get the bounding box */			cached->minx = FT_FLOOR(metrics->horiBearingX);			cached->maxx = cached->minx + FT_CEIL(metrics->width);			cached->maxy = FT_FLOOR(metrics->horiBearingY);			cached->miny = cached->maxy - FT_CEIL(metrics->height);			cached->yoffset = font->ascent - cached->maxy;			cached->advance = FT_CEIL(metrics->horiAdvance);		} else {			/* Get the bounding box for non-scalable format.			 * Again, freetype2 fills in many of the font metrics			 * with the value of 0, so some of the values we			 * need must be calculated differently with certain			 * assumptions about non-scalable formats.			 * */			cached->minx = FT_FLOOR(metrics->horiBearingX);			cached->maxx = cached->minx + FT_CEIL(metrics->horiAdvance);			cached->maxy = FT_FLOOR(metrics->horiBearingY);			cached->miny = cached->maxy - FT_CEIL(face->available_sizes[font->font_size_family].height);			cached->yoffset = 0;			cached->advance = FT_CEIL(metrics->horiAdvance);		}				/* Adjust for bold and italic text */		if( font->style & TTF_STYLE_BOLD ) {			cached->maxx += font->glyph_overhang;		}		if( font->style & TTF_STYLE_ITALIC ) {			cached->maxx += (int)ceil(font->glyph_italics);		}		cached->stored |= CACHED_METRICS;	}	if ( ((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP)) ||	     ((want & CACHED_PIXMAP) && !(cached->stored & CACHED_PIXMAP)) ) {		int mono = (want & CACHED_BITMAP);		int i;		FT_Bitmap* src;		FT_Bitmap* dst;		/* Handle the italic style */		if( font->style & TTF_STYLE_ITALIC ) {			FT_Matrix shear;			shear.xx = 1 << 16;			shear.xy = (int) ( font->glyph_italics * ( 1 << 16 ) ) / font->height;			shear.yx = 0;			shear.yy = 1 << 16;			FT_Outline_Transform( outline, &shear );		}		/* Render the glyph */		if ( mono ) {			error = FT_Render_Glyph( glyph, ft_render_mode_mono );		} else {			error = FT_Render_Glyph( glyph, ft_render_mode_normal );		}		if( error ) {			return error;		}		/* Copy over information to cache */		src = &glyph->bitmap;		if ( mono ) {			dst = &cached->bitmap;		} else {			dst = &cached->pixmap;		}		memcpy( dst, src, sizeof( *dst ) );//.........这里部分代码省略.........

  FT_LOCAL_DEF FT_Error  CID_Load_Glyph( CID_GlyphSlot  glyph,                  CID_Size       size,                  FT_Int         glyph_index,                  FT_Int         load_flags )  {    FT_Error    error;    T1_Decoder  decoder;    CID_Face    face = (CID_Face)glyph->root.face;    FT_Bool     hinting;    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;    FT_Matrix         font_matrix;    FT_Vector         font_offset;    if ( load_flags & FT_LOAD_NO_RECURSE )      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;    glyph->x_scale = size->root.metrics.x_scale;    glyph->y_scale = size->root.metrics.y_scale;    glyph->root.outline.n_points   = 0;    glyph->root.outline.n_contours = 0;    hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE   ) == 0 &&                       ( load_flags & FT_LOAD_NO_HINTING ) == 0 );    glyph->root.format = ft_glyph_format_outline;    {      error = psaux->t1_decoder_funcs->init( &decoder,                                             (FT_Face)face,                                             (FT_Size)size,                                             (FT_GlyphSlot)glyph,                                             0, /* glyph names -- XXX */                                             0, /* blend == 0 */                                             hinting,                                             cid_load_glyph );      /* set up the decoder */      decoder.builder.no_recurse = FT_BOOL(        ( ( load_flags & FT_LOAD_NO_RECURSE ) != 0 ) );      error = cid_load_glyph( &decoder, glyph_index );      font_matrix = decoder.font_matrix;      font_offset = decoder.font_offset;      /* save new glyph tables */      psaux->t1_decoder_funcs->done( &decoder );    }    /* now, set the metrics -- this is rather simple, as   */    /* the left side bearing is the xMin, and the top side */    /* bearing the yMax                                    */    if ( !error )    {      glyph->root.outline.flags &= ft_outline_owner;      glyph->root.outline.flags |= ft_outline_reverse_fill;      /* for composite glyphs, return only left side bearing and */      /* advance width                                           */      if ( load_flags & FT_LOAD_NO_RECURSE )      {        FT_Slot_Internal  internal = glyph->root.internal;        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;        glyph->root.metrics.horiAdvance  = decoder.builder.advance.x;        internal->glyph_matrix         = font_matrix;        internal->glyph_delta          = font_offset;        internal->glyph_transformed    = 1;      }      else      {        FT_BBox            cbox;        FT_Glyph_Metrics*  metrics = &glyph->root.metrics;        /* copy the _unscaled_ advance width */        metrics->horiAdvance          = decoder.builder.advance.x;        glyph->root.linearHoriAdvance = decoder.builder.advance.x;        glyph->root.internal->glyph_transformed = 0;        /* make up vertical metrics */        metrics->vertBearingX = 0;        metrics->vertBearingY = 0;        metrics->vertAdvance  = 0;        glyph->root.linearVertAdvance = 0;        glyph->root.format = ft_glyph_format_outline;        if ( size && size->root.metrics.y_ppem < 24 )          glyph->root.outline.flags |= ft_outline_high_precision;        /* apply the font matrix */        FT_Outline_Transform( &glyph->root.outline, &font_matrix );//.........这里部分代码省略.........

/* * Class:     FreetypeFont * Method:    loadGlyph0 * Signature: (JI)V */JNIEXPORT void JNICALL Java_sage_FreetypeFont_loadGlyph0  (JNIEnv *env, jobject jo, jlong fontPtr, jint glyphCode){	//FT_Face face = (FT_Face) facePtr;	FTDataStruct* fontData = (FTDataStruct*)(intptr_t) fontPtr;	FT_Activate_Size(fontData->sizePtr);	int error = FT_Load_Glyph(fontData->facePtr, glyphCode, FT_LOAD_FORCE_AUTOHINT);	if ((fontData->style & FT_STYLE_FLAG_BOLD) != 0)	{		// Apply bold effect		if (fontData->facePtr->glyph->format == FT_GLYPH_FORMAT_OUTLINE)		{			/* some reasonable strength */			FT_Pos strength = FT_MulFix(fontData->facePtr->units_per_EM,				fontData->facePtr->size->metrics.y_scale ) / 42;			FT_BBox bbox_before, bbox_after;			// The bounding box code was what XBMC was using to do this calculation; but the			// examples in the freetype library use the *4 math below which then doesn't clip			// the text when we render it.//			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_before);			FT_Outline_Embolden(&fontData->facePtr->glyph->outline, strength);  // ignore error//			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_after);//			FT_Pos dx = bbox_after.xMax - bbox_before.xMax;//			FT_Pos dy = bbox_after.yMax - bbox_before.yMax;FT_Pos dx = strength * 4;FT_Pos dy = dx;			if (fontData->facePtr->glyph->advance.x)				fontData->facePtr->glyph->advance.x += dx;			if (fontData->facePtr->glyph->advance.y)				fontData->facePtr->glyph->advance.y += dy;			fontData->facePtr->glyph->metrics.width        += dx;			fontData->facePtr->glyph->metrics.height       += dy;			fontData->facePtr->glyph->metrics.horiBearingY += dy;			fontData->facePtr->glyph->metrics.horiAdvance  += dx;			fontData->facePtr->glyph->metrics.vertBearingX -= dx / 2;			fontData->facePtr->glyph->metrics.vertBearingY += dy;			fontData->facePtr->glyph->metrics.vertAdvance  += dy;		}	}	if ((fontData->style & FT_STYLE_FLAG_ITALIC) != 0)	{		// Apply italics effect		if (fontData->facePtr->glyph->format == FT_GLYPH_FORMAT_OUTLINE)		{			/* For italic, simply apply a shear transform, with an angle */			/* of about 12 degrees.                                      */			FT_Matrix    transform;			transform.xx = 0x10000L;			transform.yx = 0x00000L;			transform.xy = 0x06000L;			transform.yy = 0x10000L;			FT_BBox bbox_before, bbox_after;			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_before);			FT_Outline_Transform(&fontData->facePtr->glyph->outline, &transform);			FT_Outline_Get_CBox(&fontData->facePtr->glyph->outline, &bbox_after);			FT_Pos dx = bbox_after.xMax - bbox_before.xMax;			FT_Pos dy = bbox_after.yMax - bbox_before.yMax;			fontData->facePtr->glyph->metrics.width        += dx;			fontData->facePtr->glyph->metrics.height       += dy;		}	}}

//.........这里部分代码省略.........    /* for composite glyphs, return only left side bearing and */    /* advance width                                           */    if ( load_flags & FT_LOAD_NO_RECURSE )    {      FT_Slot_Internal  internal = cidglyph->internal;      cidglyph->metrics.horiBearingX =        FIXED_TO_INT( decoder.builder.left_bearing.x );      cidglyph->metrics.horiAdvance =        FIXED_TO_INT( decoder.builder.advance.x );      internal->glyph_matrix      = font_matrix;      internal->glyph_delta       = font_offset;      internal->glyph_transformed = 1;    }    else    {      FT_BBox            cbox;      FT_Glyph_Metrics*  metrics = &cidglyph->metrics;      FT_Vector          advance;      /* copy the _unscaled_ advance width */      metrics->horiAdvance =        FIXED_TO_INT( decoder.builder.advance.x );      cidglyph->linearHoriAdvance =        FIXED_TO_INT( decoder.builder.advance.x );      cidglyph->internal->glyph_transformed = 0;      /* make up vertical ones */      metrics->vertAdvance        = ( face->cid.font_bbox.yMax -                                      face->cid.font_bbox.yMin ) >> 16;      cidglyph->linearVertAdvance = metrics->vertAdvance;      cidglyph->format            = FT_GLYPH_FORMAT_OUTLINE;      if ( cidsize->metrics.y_ppem < 24 )        cidglyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;      /* apply the font matrix */      FT_Outline_Transform( &cidglyph->outline, &font_matrix );      FT_Outline_Translate( &cidglyph->outline,                            font_offset.x,                            font_offset.y );      advance.x = metrics->horiAdvance;      advance.y = 0;      FT_Vector_Transform( &advance, &font_matrix );      metrics->horiAdvance = advance.x + font_offset.x;      advance.x = 0;      advance.y = metrics->vertAdvance;      FT_Vector_Transform( &advance, &font_matrix );      metrics->vertAdvance = advance.y + font_offset.y;      if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )      {        /* scale the outline and the metrics */        FT_Int       n;        FT_Outline*  cur = decoder.builder.base;        FT_Vector*   vec = cur->points;        FT_Fixed     x_scale = glyph->x_scale;        FT_Fixed     y_scale = glyph->y_scale;        /* First of all, scale the points */        if ( !hinting || !decoder.builder.hints_funcs )          for ( n = cur->n_points; n > 0; n--, vec++ )          {            vec->x = FT_MulFix( vec->x, x_scale );            vec->y = FT_MulFix( vec->y, y_scale );          }        /* Then scale the metrics */        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );      }      /* compute the other metrics */      FT_Outline_Get_CBox( &cidglyph->outline, &cbox );      metrics->width  = cbox.xMax - cbox.xMin;      metrics->height = cbox.yMax - cbox.yMin;      metrics->horiBearingX = cbox.xMin;      metrics->horiBearingY = cbox.yMax;      if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )      {        /* make up vertical ones */        ft_synthesize_vertical_metrics( metrics,                                        metrics->vertAdvance );      }    }  Exit:    return error;  }

//.........这里部分代码省略.........      k = isArabic ? ( aHarfBuzz->n_Chars - i - 1 ) : i;      aGlyphIndex = aHarfBuzz->out_glyphs[ k ];      /* apply kerning if there is any */      if ( aPrevGlyphIndex != 0 && aGlyphIndex != 0 ) {         FT_Vector delta;         /* ignore errors */         if ( FT_Get_Kerning( ftContext->m_face,                              aPrevGlyphIndex,                              aGlyphIndex,                              FT_KERNING_DEFAULT,                              &delta ) == 0 ) {            thePen_x += ( int )( ( ( double )ftContext->m_Matrix.xx *                                   ( double )delta.x ) / ( 65536.0 ) );         }      }      /* load glyph image into the slot (erase previous one) */      if ( FT_Load_Glyph( ftContext->m_face,                           aGlyphIndex,                           FT_LOAD_DEFAULT ) != 0 ) {         continue; /* ignore errors */      }      // if we are synthesising italic then shear outline      if ( ftContext->m_Synth & SynthItalic ) {         FT_Matrix m;         m.xx = 65536;         m.yy = 65536;         m.xy = 19660;         m.yx = 0;         FT_Outline_Transform( &slot->outline, &m );      }      /* if we are doing first pass of two color then fatten */      if ( ( ftContext->m_Synth & SynthTwoColor ) && j == 0 ) {         if ( FT_Outline_Embolden( &slot->outline,                                    ftContext->m_StrokeWidth << 2 ) != 0 ) {            continue;         }      }      // if we are doing second pass of two color then translate      if ( ( ftContext->m_Synth & SynthTwoColor ) && j == 1 ) {         FT_Outline_Translate( &slot->outline,                                ftContext->m_StrokeWidth * 2,                                ftContext->m_StrokeWidth * 2 );      }      /* if we are synthesising bold then perform fattening operation */      if ( ftContext->m_Synth & SynthBold ) {         if ( FT_Outline_Embolden( &slot->outline,                                    ftContext->m_Boldness << 1 ) != 0 ) {            continue;         }      }      /* if we are synthesising stroke font then stroke it */      if ( ftContext->m_Synth & SynthStroke ) {         if ( ft_OutlineStroke( ftContext->m_library,                           &slot->outline, ftContext->m_StrokeWidth ) != 0 ) {            continue;         }      }

//.........这里部分代码省略.........        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;        glyph->root.metrics.horiAdvance  = decoder.builder.advance.x;        internal->glyph_matrix           = font_matrix;        internal->glyph_delta            = font_offset;        internal->glyph_transformed      = 1;      }      else      {        FT_BBox            cbox;        FT_Glyph_Metrics*  metrics = &glyph->root.metrics;        /* copy the _unscaled_ advance width */        metrics->horiAdvance                    = decoder.builder.advance.x;        glyph->root.linearHoriAdvance           = decoder.builder.advance.x;        glyph->root.internal->glyph_transformed = 0;        /* make up vertical metrics */        metrics->vertBearingX = 0;        metrics->vertBearingY = 0;        metrics->vertAdvance  = 0;        glyph->root.linearVertAdvance = 0;        glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;        if ( size && size->root.metrics.y_ppem < 24 )          glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;#if 1        /* apply the font matrix, if any */        FT_Outline_Transform( &glyph->root.outline, &font_matrix );        FT_Outline_Translate( &glyph->root.outline,                              font_offset.x,                              font_offset.y );#endif        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur = decoder.builder.base;          FT_Vector*   vec = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points, if we are not hinting */          if ( !hinting )            for ( n = cur->n_points; n > 0; n--, vec++ )            {              vec->x = FT_MulFix( vec->x, x_scale );              vec->y = FT_MulFix( vec->y, y_scale );            }          FT_Outline_Get_CBox( &glyph->root.outline, &cbox );          /* Then scale the metrics */          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  y_scale );          metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );          metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );

//.........这里部分代码省略.........      {        index = fnt->sf_code[k];        if (index < 0)          continue;        j = k;      }      else        index = k;      Num = FT_Get_Char_Index(face, index);      /* now we try to get a vertical glyph form */      if (has_gsub)        Num = Get_Vert(Num);      if (Num < 0)        oops("Failure on cmap mapping from %s.", fnt->ttfname);      if (Num == 0)        continue;      if (!only_range)        if (Num <= 256)          index_array[Num] = 1;    }    else    {      Num = k;      index = 0;    }    error = FT_Load_Glyph(face, Num, flags);    if (!error)    {      if (fnt->efactor != 1.0 || fnt->slant != 0.0 )        FT_Outline_Transform(&face->glyph->outline, &matrix1);      if (fnt->rotate)        FT_Outline_Transform(&face->glyph->outline, &matrix2);      error = FT_Outline_Get_BBox(&face->glyph->outline, &bbox); /* we need the non-                                                                    grid-fitted bbox */    }    if (!error)    {      if (fnt->PSnames)      {        (void)FT_Get_Glyph_Name(face, Num, buff, 128);        an = newstring(buff);      }      else        an = code_to_adobename(index);      /* ignore characters not usable for typesetting with TeX */      if (strcmp(an, ".notdef") == 0)        continue;      if (strcmp(an, ".null") == 0)        continue;      if (strcmp(an, "nonmarkingreturn") == 0)        continue;      ti = newchar(fnt);      ti->charcode = index;      ti->glyphindex = Num;      ti->adobename = an;      ti->llx = bbox.xMin * 1000 / fnt->units_per_em;      ti->lly = bbox.yMin * 1000 / fnt->units_per_em;      ti->urx = bbox.xMax * 1000 / fnt->units_per_em;      ti->ury = bbox.yMax * 1000 / fnt->units_per_em;

//.........这里部分代码省略.........          FT_Short   vertBearingY = 0;          FT_UShort  vertAdvance  = 0;          ( (SFNT_Service)face->sfnt )->get_metrics( face, 1,                                                     glyph_index,                                                     &vertBearingY,                                                     &vertAdvance );          metrics->vertBearingY = vertBearingY;          metrics->vertAdvance  = vertAdvance;        }        else        {          /* make up vertical ones */          if ( face->os2.version != 0xFFFFU )            metrics->vertAdvance = (FT_Pos)( face->os2.sTypoAscender -                                             face->os2.sTypoDescender );          else            metrics->vertAdvance = (FT_Pos)( face->horizontal.Ascender -                                             face->horizontal.Descender );        }        glyph->root.linearVertAdvance = metrics->vertAdvance;        glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;        glyph->root.outline.flags = 0;        if ( size && size->root.metrics.y_ppem < 24 )          glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;        glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;        /* apply the font matrix, if any */        if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||             font_matrix.xy != 0        || font_matrix.yx != 0        )        {          FT_Outline_Transform( &glyph->root.outline, &font_matrix );          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,                                            font_matrix.xx );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,                                            font_matrix.yy );        }        if ( font_offset.x || font_offset.y )        {          FT_Outline_Translate( &glyph->root.outline,                                font_offset.x,                                font_offset.y );          metrics->horiAdvance += font_offset.x;          metrics->vertAdvance += font_offset.y;        }        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur     = &glyph->root.outline;          FT_Vector*   vec     = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points */          if ( !hinting || !decoder.builder.hints_funcs )            for ( n = cur->n_points; n > 0; n--, vec++ )            {              vec->x = FT_MulFix( vec->x, x_scale );              vec->y = FT_MulFix( vec->y, y_scale );            }          /* Then scale the metrics */          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );        }        /* compute the other metrics */        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );        metrics->width  = cbox.xMax - cbox.xMin;        metrics->height = cbox.yMax - cbox.yMin;        metrics->horiBearingX = cbox.xMin;        metrics->horiBearingY = cbox.yMax;        if ( has_vertical_info )          metrics->vertBearingX = metrics->horiBearingX -                                    metrics->horiAdvance / 2;        else        {          if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )            ft_synthesize_vertical_metrics( metrics,                                            metrics->vertAdvance );        }      }    }    return error;  }

//.........这里部分代码省略.........          slot->lsb_delta = loader->pp1.x - pp1x;          slot->rsb_delta = loader->pp2.x - pp2x;        }      }      /* `light' mode uses integer advance widths */      /* but sets `lsb_delta' and `rsb_delta'     */      else      {        FT_Pos  pp1x = loader->pp1.x;        FT_Pos  pp2x = loader->pp2.x;        loader->pp1.x = FT_PIX_ROUND( pp1x );        loader->pp2.x = FT_PIX_ROUND( pp2x );        slot->lsb_delta = loader->pp1.x - pp1x;        slot->rsb_delta = loader->pp2.x - pp2x;      }      break;    default:      /* we don't support other formats (yet?) */      error = FT_THROW( Unimplemented_Feature );    }  Hint_Metrics:    {      FT_BBox    bbox;      FT_Vector  vvector;      vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;      vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;      vvector.x = FT_MulFix( vvector.x, style_metrics->scaler.x_scale );      vvector.y = FT_MulFix( vvector.y, style_metrics->scaler.y_scale );      /* transform the hinted outline if needed */      if ( loader->transformed )      {        FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );        FT_Vector_Transform( &vvector, &loader->trans_matrix );      }      /* we must translate our final outline by -pp1.x and compute */      /* the new metrics                                           */      if ( loader->pp1.x )        FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );      bbox.xMin = FT_PIX_FLOOR( bbox.xMin );      bbox.yMin = FT_PIX_FLOOR( bbox.yMin );      bbox.xMax = FT_PIX_CEIL(  bbox.xMax );      bbox.yMax = FT_PIX_CEIL(  bbox.yMax );      slot->metrics.width        = bbox.xMax - bbox.xMin;      slot->metrics.height       = bbox.yMax - bbox.yMin;      slot->metrics.horiBearingX = bbox.xMin;      slot->metrics.horiBearingY = bbox.yMax;      slot->metrics.vertBearingX = FT_PIX_FLOOR( bbox.xMin + vvector.x );      slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );      /* for mono-width fonts (like Andale, Courier, etc.) we need */      /* to keep the original rounded advance width; ditto for     */      /* digits if all have the same advance width                 */      if ( scaler.render_mode != FT_RENDER_MODE_LIGHT                       &&           ( FT_IS_FIXED_WIDTH( slot->face )                              ||             ( af_face_globals_is_digit( loader->globals, glyph_index ) &&               style_metrics->digits_have_same_width                    ) ) )      {        slot->metrics.horiAdvance =          FT_MulFix( slot->metrics.horiAdvance,                     style_metrics->scaler.x_scale );        /* Set delta values to 0.  Otherwise code that uses them is */        /* going to ruin the fixed advance width.                   */        slot->lsb_delta = 0;        slot->rsb_delta = 0;      }      else      {        /* non-spacing glyphs must stay as-is */        if ( slot->metrics.horiAdvance )          slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;      }      slot->metrics.vertAdvance = FT_MulFix( slot->metrics.vertAdvance,                                             style_metrics->scaler.y_scale );      slot->metrics.horiAdvance = FT_PIX_ROUND( slot->metrics.horiAdvance );      slot->metrics.vertAdvance = FT_PIX_ROUND( slot->metrics.vertAdvance );      slot->format  = FT_GLYPH_FORMAT_OUTLINE;    }  Exit:    return error;  }

//.........这里部分代码省略.........      /* advance width                                           */      if ( load_flags & FT_LOAD_NO_RECURSE )      {        FT_Slot_Internal  internal = glyph->root.internal;                        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;        glyph->root.metrics.horiAdvance  = decoder.builder.advance.x;        internal->glyph_matrix           = font_matrix;        internal->glyph_delta            = font_offset;        internal->glyph_transformed      = 1;      }      else      {        FT_BBox            cbox;        FT_Glyph_Metrics*  metrics = &glyph->root.metrics;        /* copy the _unscaled_ advance width */        metrics->horiAdvance                    = decoder.builder.advance.x;        glyph->root.linearHoriAdvance           = decoder.builder.advance.x;        glyph->root.internal->glyph_transformed = 0;        /* make up vertical metrics */        metrics->vertBearingX = 0;        metrics->vertBearingY = 0;        metrics->vertAdvance  = 0;        glyph->root.linearVertAdvance = 0;        glyph->root.format = ft_glyph_format_outline;        if ( size && size->root.metrics.y_ppem < 24 )          glyph->root.outline.flags |= ft_outline_high_precision;        /* apply the font matrix */        FT_Outline_Transform( &glyph->root.outline, &font_matrix );        FT_Outline_Translate( &glyph->root.outline,                              font_offset.x,                              font_offset.y );#if 0        glyph->root.outline.second_pass    = TRUE;        glyph->root.outline.high_precision = size->root.metrics.y_ppem < 24;        glyph->root.outline.dropout_mode   = 2;#endif /* 0 */        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur = decoder.builder.base;          FT_Vector*   vec = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points */          for ( n = cur->n_points; n > 0; n--, vec++ )          {            vec->x = FT_MulFix( vec->x, x_scale );            vec->y = FT_MulFix( vec->y, y_scale );          }          FT_Outline_Get_CBox( &glyph->root.outline, &cbox );          /* Then scale the metrics */          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  y_scale );          metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );          metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );        }        /* compute the other metrics */        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );        /* grid fit the bounding box if necessary */        if ( hinting )        {          cbox.xMin &= -64;          cbox.yMin &= -64;          cbox.xMax  = ( cbox.xMax+63 ) & -64;          cbox.yMax  = ( cbox.yMax+63 ) & -64;        }        metrics->width  = cbox.xMax - cbox.xMin;        metrics->height = cbox.yMax - cbox.yMin;        metrics->horiBearingX = cbox.xMin;        metrics->horiBearingY = cbox.yMax;      }    }  Exit:    return error;  }

//.........这里部分代码省略.........      {        FT_Pos  pp1x = loader->pp1.x;        FT_Pos  pp2x = loader->pp2.x;        loader->pp1.x = FT_PIX_ROUND( pp1x + hints->xmin_delta );        loader->pp2.x = FT_PIX_ROUND( pp2x + hints->xmax_delta );        slot->lsb_delta = loader->pp1.x - pp1x;        slot->rsb_delta = loader->pp2.x - pp2x;      }      break;    default:      /* we don't support other formats (yet?) */      error = FT_THROW( Unimplemented_Feature );    }  Hint_Metrics:    {      FT_BBox    bbox;      FT_Vector  vvector;      vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;      vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;      vvector.x = FT_MulFix( vvector.x, metrics->scaler.x_scale );      vvector.y = FT_MulFix( vvector.y, metrics->scaler.y_scale );      /* transform the hinted outline if needed */      if ( loader->transformed )      {        FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );        FT_Vector_Transform( &vvector, &loader->trans_matrix );      }#if 1      /* we must translate our final outline by -pp1.x and compute */      /* the new metrics                                           */      if ( loader->pp1.x )        FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );#endif      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );      bbox.xMin = FT_PIX_FLOOR( bbox.xMin );      bbox.yMin = FT_PIX_FLOOR( bbox.yMin );      bbox.xMax = FT_PIX_CEIL(  bbox.xMax );      bbox.yMax = FT_PIX_CEIL(  bbox.yMax );      slot->metrics.width        = bbox.xMax - bbox.xMin;      slot->metrics.height       = bbox.yMax - bbox.yMin;      slot->metrics.horiBearingX = bbox.xMin;      slot->metrics.horiBearingY = bbox.yMax;      slot->metrics.vertBearingX = FT_PIX_FLOOR( bbox.xMin + vvector.x );      slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );      /* for mono-width fonts (like Andale, Courier, etc.) we need */      /* to keep the original rounded advance width; ditto for     */      /* digits if all have the same advance width                 */#if 0      if ( !FT_IS_FIXED_WIDTH( slot->face ) )        slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;      else        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,                                               x_scale );

//.........这里部分代码省略.........            /* for now, only use the current point coordinates;    */            /* we may consider another approach in the near future */            p1 = gloader->base.outline.points + start_point + k;            p2 = gloader->base.outline.points + start_point + l;            x = p1->x - p2->x;            y = p1->y - p2->y;          }          else          {            x = FT_MulFix( subglyph->arg1, hints->x_scale ) + hints->x_delta;            y = FT_MulFix( subglyph->arg2, hints->y_scale ) + hints->y_delta;            x = FT_PIX_ROUND(x);            y = FT_PIX_ROUND(y);          }          {            FT_Outline  dummy = gloader->base.outline;            dummy.points  += num_base_points;            dummy.n_points = (short)num_new_points;            FT_Outline_Translate( &dummy, x, y );          }        }      }      break;    default:      /* we don't support other formats (yet?) */      error = FT_Err_Unimplemented_Feature;    }  Hint_Metrics:    if ( depth == 0 )    {      FT_BBox  bbox;      /* transform the hinted outline if needed */      if ( loader->transformed )        FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );      /* we must translate our final outline by -pp1.x and compute */      /* the new metrics                                           */      if ( loader->pp1.x )        FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );      bbox.xMin  = FT_PIX_FLOOR(  bbox.xMin );      bbox.yMin  = FT_PIX_FLOOR(  bbox.yMin );      bbox.xMax  = FT_PIX_CEIL( bbox.xMax );      bbox.yMax  = FT_PIX_CEIL( bbox.yMax );      slot->metrics.width        = bbox.xMax - bbox.xMin;      slot->metrics.height       = bbox.yMax - bbox.yMin;      slot->metrics.horiBearingX = bbox.xMin;      slot->metrics.horiBearingY = bbox.yMax;      /* for mono-width fonts (like Andale, Courier, etc.) we need */      /* to keep the original rounded advance width                */#if 0      if ( !FT_IS_FIXED_WIDTH( slot->face ) )        slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;      else        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,                                               x_scale );#else      /* for mono-width fonts (like Andale, Courier, etc.) we need */      /* to keep the original rounded advance width                */      if ( !FT_IS_FIXED_WIDTH( slot->face ) )        slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;      else        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,                                               metrics->scaler.x_scale );#endif      slot->metrics.horiAdvance = FT_PIX_ROUND( slot->metrics.horiAdvance );      /* now copy outline into glyph slot */      FT_GlyphLoader_Rewind( internal->loader );      error = FT_GlyphLoader_CopyPoints( internal->loader, gloader );      if ( error )        goto Exit;      slot->outline = internal->loader->base.outline;      slot->format  = FT_GLYPH_FORMAT_OUTLINE;    }#ifdef DEBUG_HINTER    af_debug_hinter = hinter;#endif  Exit:    return error;  }

static FT_ErrorLoad_Glyph(TTF_Font * font, Uint16 ch, c_glyph * cached, int want){    FT_Face face;    FT_Error error;    FT_GlyphSlot glyph;    FT_Glyph_Metrics *metrics;    FT_Outline *outline;    if(!font || !font->face)    {        return FT_Err_Invalid_Handle;    }    face = font->face;    /* Load the glyph */    if(!cached->index)    {        cached->index = FT_Get_Char_Index(face, ch);    }    error = FT_Load_Glyph(face, cached->index, FT_LOAD_DEFAULT);    if(error)    {        return error;    }    /* Get our glyph shortcuts */    glyph = face->glyph;    metrics = &glyph->metrics;    outline = &glyph->outline;    /* Get the glyph metrics if desired */    if((want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS))    {        if(FT_IS_SCALABLE(face))        {            /* Get the bounding box */            cached->minx = FT_FLOOR(metrics->horiBearingX);            cached->maxx = cached->minx + FT_CEIL(metrics->width);            cached->maxy = FT_FLOOR(metrics->horiBearingY);            cached->miny = cached->maxy - FT_CEIL(metrics->height);            cached->yoffset = font->ascent - cached->maxy;            cached->advance = FT_CEIL(metrics->horiAdvance);        }        else        {            /* Get the bounding box for non-scalable format.             * Again, freetype2 fills in many of the font metrics             * with the value of 0, so some of the values we             * need must be calculated differently with certain             * assumptions about non-scalable formats.             * */            cached->minx = FT_FLOOR(metrics->horiBearingX);            cached->maxx = cached->minx + FT_CEIL(metrics->horiAdvance);            cached->maxy = FT_FLOOR(metrics->horiBearingY);            cached->miny =                cached->maxy -                FT_CEIL(face->available_sizes[font->font_size_family].height);            cached->yoffset = 0;            cached->advance = FT_CEIL(metrics->horiAdvance);        }        /* Adjust for bold and italic text */        if(font->style & TTF_STYLE_BOLD)        {            cached->maxx += font->glyph_overhang;        }        if(font->style & TTF_STYLE_ITALIC)        {            cached->maxx += (int) ceil(font->glyph_italics);        }        cached->stored |= CACHED_METRICS;    }    if(((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP)) ||            ((want & CACHED_PIXMAP) && !(cached->stored & CACHED_PIXMAP)))    {        int mono = (want & CACHED_BITMAP);        int i;        FT_Bitmap *src;        FT_Bitmap *dst;        /* Handle the italic style */        if(font->style & TTF_STYLE_ITALIC)        {            FT_Matrix shear;            shear.xx = 1 << 16;            shear.xy = (int) (font->glyph_italics * (1 << 16)) / font->height;            shear.yx = 0;            shear.yy = 1 << 16;            FT_Outline_Transform(outline, &shear);        }        /* Render the glyph */        if(mono)        {            error = FT_Render_Glyph(glyph, ft_render_mode_mono);//.........这里部分代码省略.........

//.........这里部分代码省略.........      {        FT_Slot_Internal  internal = glyph->root.internal;        glyph->root.metrics.horiBearingX =          FIXED_TO_INT( decoder.builder.left_bearing.x );        glyph->root.metrics.horiAdvance  =          FIXED_TO_INT( decoder.builder.advance.x );        internal->glyph_matrix           = font_matrix;        internal->glyph_delta            = font_offset;        internal->glyph_transformed      = 1;      }      else      {        FT_BBox            cbox;        FT_Glyph_Metrics*  metrics = &glyph->root.metrics;        FT_Vector          advance;        /* copy the _unscaled_ advance width */        metrics->horiAdvance =          FIXED_TO_INT( decoder.builder.advance.x );        glyph->root.linearHoriAdvance =          FIXED_TO_INT( decoder.builder.advance.x );        glyph->root.internal->glyph_transformed = 0;        /* make up vertical ones */        metrics->vertAdvance = ( face->type1.font_bbox.yMax -                                 face->type1.font_bbox.yMin ) >> 16;        glyph->root.linearVertAdvance = metrics->vertAdvance;        glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;        if ( size && size->root.metrics.y_ppem < 24 )          glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;#if 1        /* apply the font matrix, if any */        if ( font_matrix.xx != 0x10000L || font_matrix.yy != font_matrix.xx ||             font_matrix.xy != 0        || font_matrix.yx != 0              )          FT_Outline_Transform( &glyph->root.outline, &font_matrix );        if ( font_offset.x || font_offset.y )          FT_Outline_Translate( &glyph->root.outline,                                font_offset.x,                                font_offset.y );        advance.x = metrics->horiAdvance;        advance.y = 0;        FT_Vector_Transform( &advance, &font_matrix );        metrics->horiAdvance = advance.x + font_offset.x;        advance.x = 0;        advance.y = metrics->vertAdvance;        FT_Vector_Transform( &advance, &font_matrix );        metrics->vertAdvance = advance.y + font_offset.y;#endif        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur = decoder.builder.base;          FT_Vector*   vec = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points, if we are not hinting */          if ( !hinting || ! decoder.builder.hints_funcs )            for ( n = cur->n_points; n > 0; n--, vec++ )            {              vec->x = FT_MulFix( vec->x, x_scale );              vec->y = FT_MulFix( vec->y, y_scale );            }          /* Then scale the metrics */          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  y_scale );        }        /* compute the other metrics */        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );        metrics->width  = cbox.xMax - cbox.xMin;        metrics->height = cbox.yMax - cbox.yMin;        metrics->horiBearingX = cbox.xMin;        metrics->horiBearingY = cbox.yMax;        /* make up vertical ones */        ft_synthesize_vertical_metrics( metrics,                                        metrics->vertAdvance );      }      /* Set control data to the glyph charstrings.  Note that this is */      /* _not_ zero-terminated.                                        */      glyph->root.control_data = (FT_Byte*)glyph_data.pointer;      glyph->root.control_len  = glyph_data.length;    }

static void loadglyph(font_t *f, glui32 cid){    FT_Vector v;    int err;    glui32 gid;    int x;    bitmap_t glyphs[GLI_SUBPIX];    int adv;    gid = FT_Get_Char_Index(f->face, cid);    if (gid == 0)        gid = FT_Get_Char_Index(f->face, '?');    for (x = 0; x < GLI_SUBPIX; x++)    {        v.x = (x * 64) / GLI_SUBPIX;        v.y = 0;        FT_Set_Transform(f->face, 0, &v);        err = FT_Load_Glyph(f->face, gid,                FT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING);        if (err)            winabort("FT_Load_Glyph");        if (f->make_bold)            FT_Outline_Embolden(&f->face->glyph->outline, FT_MulFix(f->face->units_per_EM, f->face->size->metrics.y_scale) / 24);        if (f->make_oblique)            FT_Outline_Transform(&f->face->glyph->outline, &ftmat);        if (gli_conf_lcd)            err = FT_Render_Glyph(f->face->glyph, FT_RENDER_MODE_LCD);        else            err = FT_Render_Glyph(f->face->glyph, FT_RENDER_MODE_LIGHT);        if (err)            winabort("FT_Render_Glyph");        adv = (f->face->glyph->advance.x * GLI_SUBPIX + 32) / 64;        glyphs[x].lsb = f->face->glyph->bitmap_left;        glyphs[x].top = f->face->glyph->bitmap_top;        glyphs[x].w = f->face->glyph->bitmap.width;        glyphs[x].h = f->face->glyph->bitmap.rows;        glyphs[x].pitch = f->face->glyph->bitmap.pitch;        glyphs[x].data =            malloc(glyphs[x].pitch * glyphs[x].h);                if (gli_conf_lcd)                    gammacopy_lcd(glyphs[x].data,                            f->face->glyph->bitmap.buffer,                            glyphs[x].w, glyphs[x].h, glyphs[x].pitch);                else                    gammacopy(glyphs[x].data,                            f->face->glyph->bitmap.buffer,                            glyphs[x].pitch * glyphs[x].h);    }    if (cid < 256)    {        f->lowloaded[cid/8] |= (1 << (cid%8));        f->lowadvs[cid] = adv;        memcpy(f->lowglyphs[cid], glyphs, sizeof glyphs);    }    else    {        int idx = findhighglyph(cid, f->highentries, f->num_highentries);        if (idx < 0)        {            idx = ~idx;            /* make room if needed */            if (f->alloced_highentries == f->num_highentries)            {                fentry_t *newentries;                int newsize = f->alloced_highentries * 2;                if (!newsize)                    newsize = 2;                newentries = malloc(newsize * sizeof(fentry_t));                if (!newentries)                    return;                if (f->highentries)                {                    memcpy(newentries, f->highentries, f->num_highentries * sizeof(fentry_t));                    free(f->highentries);                }                f->highentries = newentries;                f->alloced_highentries = newsize;            }            /* insert new glyph */            memmove(&f->highentries[idx+1], &f->highentries[idx], (f->num_highentries - idx) * sizeof(fentry_t));            f->highentries[idx].cid = cid;            f->highentries[idx].adv = adv;            memcpy(f->highentries[idx].glyph, glyphs, sizeof glyphs);            f->num_highentries++;        }    }}

//.........这里部分代码省略.........    FT_Fixed  em_ratio = FT_DivFix( af_intToFixed( 1000 ), em_size );    FT_Matrix  scale_down_matrix = { 0x10000L, 0, 0, 0x10000L };    /* Skip stem darkening for broken fonts. */    if ( !face->units_per_EM )    {      error = FT_ERR( Corrupted_Font_Header );      goto Exit;    }    /*     * We depend on the writing system (script analyzers) to supply     * standard widths for the script of the glyph we are looking at.  If     * it can't deliver, stem darkening is disabled.     */    writing_system_class =      af_writing_system_classes[style_metrics->style_class->writing_system];    if ( writing_system_class->style_metrics_getstdw )      writing_system_class->style_metrics_getstdw( style_metrics,                                                   &stdHW,                                                   &stdVW );    else    {      error = FT_ERR( Unimplemented_Feature );      goto Exit;    }    if ( size_changed                                               ||         ( stdVW > 0 && stdVW != globals->standard_vertical_width ) )    {      FT_Fixed  darken_by_font_units_x, darken_x;      darken_by_font_units_x =        af_intToFixed( af_loader_compute_darkening( loader,                                                    face,                                                    stdVW ) );      darken_x = FT_DivFix( FT_MulFix( darken_by_font_units_x,                                       size_metrics->x_scale ),                            em_ratio );      globals->standard_vertical_width = stdVW;      globals->stem_darkening_for_ppem = size_metrics->x_ppem;      globals->darken_x                = af_fixedToInt( darken_x );    }    if ( size_changed                                                 ||         ( stdHW > 0 && stdHW != globals->standard_horizontal_width ) )    {      FT_Fixed  darken_by_font_units_y, darken_y;      darken_by_font_units_y =        af_intToFixed( af_loader_compute_darkening( loader,                                                    face,                                                    stdHW ) );      darken_y = FT_DivFix( FT_MulFix( darken_by_font_units_y,                                       size_metrics->y_scale ),                            em_ratio );      globals->standard_horizontal_width = stdHW;      globals->stem_darkening_for_ppem   = size_metrics->x_ppem;      globals->darken_y                  = af_fixedToInt( darken_y );      /*       * Scale outlines down on the Y-axis to keep them inside their blue       * zones.  The stronger the emboldening, the stronger the downscaling       * (plus heuristical padding to prevent outlines still falling out       * their zones due to rounding).       *       * Reason: `FT_Outline_Embolden' works by shifting the rightmost       * points of stems farther to the right, and topmost points farther       * up.  This positions points on the Y-axis outside their       * pre-computed blue zones and leads to distortion when applying the       * hints in the code further below.  Code outside this emboldening       * block doesn't know we are presenting it with modified outlines the       * analyzer didn't see!       *       * An unfortunate side effect of downscaling is that the emboldening       * effect is slightly decreased.  The loss becomes more pronounced       * versus the CFF driver at smaller sizes, e.g., at 9ppem and below.       */      globals->scale_down_factor =        FT_DivFix( em_size - ( darken_by_font_units_y + af_intToFixed( 8 ) ),                   em_size );    }    FT_Outline_EmboldenXY( &slot->outline,                           globals->darken_x,                           globals->darken_y );    scale_down_matrix.yy = globals->scale_down_factor;    FT_Outline_Transform( &slot->outline, &scale_down_matrix );  Exit:    return error;  }

static FT_Error Load_Glyph( TTF_Font* font, unsigned short ch, c_glyph* cached, int want){        FT_Face face;        FT_Error error;        FT_GlyphSlot glyph;        FT_Glyph_Metrics* metrics;        FT_Outline* outline;                                      assert( font );        assert( font->face );        face = font->face;        /* Load the glyph */        if ( ! cached->index ) {                cached->index = FT_Get_Char_Index( face, ch );        }        error = FT_Load_Glyph( face, cached->index, FT_LOAD_DEFAULT );        if( error ) {                return error;        }        /* Get our glyph shortcuts */        glyph = face->glyph;        metrics = &glyph->metrics;        outline = &glyph->outline;        /* Get the glyph metrics if desired */        if ( (want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS) ) {                /* Get the bounding box */                cached->minx = FT_FLOOR(metrics->horiBearingX);                cached->maxx = cached->minx + FT_CEIL(metrics->width);                cached->maxy = FT_FLOOR(metrics->horiBearingY);                cached->miny = cached->maxy - FT_CEIL(metrics->height);                cached->yoffset = font->ascent - cached->maxy;                cached->advance = FT_CEIL(metrics->horiAdvance);                /* Adjust for bold and italic text */                if( font->style & TTF_STYLE_BOLD ) {                        cached->maxx += font->glyph_overhang;                }                if( font->style & TTF_STYLE_ITALIC ) {                        cached->maxx += (int)ceil(font->glyph_italics);                }                cached->stored |= CACHED_METRICS;        }        if ( ((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP)) ||             ((want & CACHED_PIXMAP) && !(cached->stored & CACHED_PIXMAP)) ) {                int mono = (want & CACHED_BITMAP);                int i;                FT_Bitmap* src;                FT_Bitmap* dst;                /* Handle the italic style */                if( font->style & TTF_STYLE_ITALIC ) {                        FT_Matrix shear;                        shear.xx = 1 << 16;                        shear.xy = (int) ( font->glyph_italics * ( 1 << 16 ) )/ font->height;                        shear.yx = 0;                        shear.yy = 1 << 16;                        FT_Outline_Transform( outline, &shear );                }                /* Render the glyph */                if ( mono ) {                        error = FT_Render_Glyph( glyph, ft_render_mode_mono );                } else {                        error = FT_Render_Glyph( glyph, ft_render_mode_normal );                }                if( error ) {                        return error;                }                /* Copy over information to cache */                src = &glyph->bitmap;                if ( mono ) {                        dst = &cached->bitmap;                } else {                        dst = &cached->pixmap;                }                memcpy( dst, src, sizeof( *dst ) );                if ( mono ) {                        dst->pitch *= 8;                }                /* Adjust for bold and italic text */                if( font->style & TTF_STYLE_BOLD ) {                        int bump = font->glyph_overhang;                        dst->pitch += bump;                        dst->width += bump;                }                if( font->style & TTF_STYLE_ITALIC ) {                        int bump = (int)ceil(font->glyph_italics);                        dst->pitch += bump;                        dst->width += bump;                }                if (dst->rows != 0) {//.........这里部分代码省略.........

  pfr_slot_load( FT_GlyphSlot  pfrslot,         /* PFR_Slot */                 FT_Size       pfrsize,         /* PFR_Size */                 FT_UInt       gindex,                 FT_Int32      load_flags )  {    PFR_Slot     slot    = (PFR_Slot)pfrslot;    PFR_Size     size    = (PFR_Size)pfrsize;    FT_Error     error;    PFR_Face     face    = (PFR_Face)pfrslot->face;    PFR_Char     gchar;    FT_Outline*  outline = &pfrslot->outline;    FT_ULong     gps_offset;    if ( gindex > 0 )      gindex--;    /* check that the glyph index is correct */    FT_ASSERT( gindex < face->phy_font.num_chars );    /* try to load an embedded bitmap */    if ( ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP ) ) == 0 )    {      error = pfr_slot_load_bitmap( slot, size, gindex );      if ( error == 0 )        goto Exit;    }    if ( load_flags & FT_LOAD_SBITS_ONLY )    {      error = PFR_Err_Invalid_Argument;      goto Exit;    }    gchar               = face->phy_font.chars + gindex;    pfrslot->format     = FT_GLYPH_FORMAT_OUTLINE;    outline->n_points   = 0;    outline->n_contours = 0;    gps_offset          = face->header.gps_section_offset;    /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */    error = pfr_glyph_load( &slot->glyph, face->root.stream,                            gps_offset, gchar->gps_offset, gchar->gps_size );    if ( !error )    {      FT_BBox            cbox;      FT_Glyph_Metrics*  metrics = &pfrslot->metrics;      FT_Pos             advance;      FT_Int             em_metrics, em_outline;      FT_Bool            scaling;      scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );      /* copy outline data */      *outline = slot->glyph.loader->base.outline;      outline->flags &= ~FT_OUTLINE_OWNER;      outline->flags |= FT_OUTLINE_REVERSE_FILL;      if ( size && pfrsize->metrics.y_ppem < 24 )        outline->flags |= FT_OUTLINE_HIGH_PRECISION;      /* compute the advance vector */      metrics->horiAdvance = 0;      metrics->vertAdvance = 0;      advance    = gchar->advance;      em_metrics = face->phy_font.metrics_resolution;      em_outline = face->phy_font.outline_resolution;      if ( em_metrics != em_outline )        advance = FT_MulDiv( advance, em_outline, em_metrics );      if ( face->phy_font.flags & PFR_PHY_VERTICAL )        metrics->vertAdvance = advance;      else        metrics->horiAdvance = advance;      pfrslot->linearHoriAdvance = metrics->horiAdvance;      pfrslot->linearVertAdvance = metrics->vertAdvance;      /* make-up vertical metrics(?) */      metrics->vertBearingX = 0;      metrics->vertBearingY = 0;      /* Apply the font matrix, if any.                 */      /* TODO: Test existing fonts with unusual matrix  */      /* whether we have to adjust Units per EM.        */      {        FT_Matrix font_matrix;        font_matrix.xx = face->log_font.matrix[0] << 8;        font_matrix.yx = face->log_font.matrix[1] << 8;        font_matrix.xy = face->log_font.matrix[2] << 8;        font_matrix.yy = face->log_font.matrix[3] << 8;        FT_Outline_Transform( outline, &font_matrix );//.........这里部分代码省略.........

  static FT_Error  Render_Slanted( int  num_indices,                  int  first_index )  {    int           start_x, start_y, step_y, x, y;    int           i;    FT_Size       size;    FT_Face       face;    FT_GlyphSlot  slot;    FT_Matrix  shear;    error = FTDemo_Get_Size( handle, &size );    if ( error )    {      /* probably a non-existent bitmap font size */      return error;    }    INIT_SIZE( size, start_x, start_y, step_y, x, y );    face = size->face;    slot = face->glyph;    /***************************************************************/    /*                                                             */    /*  2*2 affine transformation matrix, 16.16 fixed float format */    /*                                                             */    /*  Shear matrix:                                              */    /*                                                             */    /*         | x' |     | 1  k |   | x |          x' = x + ky    */    /*         |    |  =  |      | * |   |   <==>                  */    /*         | y' |     | 0  1 |   | y |          y' = y         */    /*                                                             */    /*        outline'     shear    outline                        */    /*                                                             */    /***************************************************************/    shear.xx = 1 << 16;    shear.xy = (FT_Fixed)( status.slant * ( 1 << 16 ) );    shear.yx = 0;    shear.yy = 1 << 16;    for ( i = first_index; i < num_indices; i++ )    {      int  gindex;      if ( handle->encoding == FT_ENCODING_NONE )        gindex = i;      else        gindex = FTDemo_Get_Index( handle, i );      error = FT_Load_Glyph( face, gindex, handle->load_flags );      if ( !error )      {        FT_Outline_Transform( &slot->outline, &shear );        error = FTDemo_Draw_Slot( handle, display, slot, &x, &y );        if ( error )          goto Next;        else if ( X_TOO_LONG( x, size, display ) )        {          x  = start_x;          y += step_y;          if ( Y_TOO_LONG( y, size, display ) )            break;        }      }      else    Next:        status.Fail++;    }    return error;  }

//.........这里部分代码省略.........        internal->glyph_matrix      = font_matrix;        internal->glyph_delta       = font_offset;        internal->glyph_transformed = 1;      }      else      {        FT_BBox            cbox;        FT_Glyph_Metrics*  metrics = &t1glyph->metrics;        /* copy the _unscaled_ advance width */        metrics->horiAdvance =          FIXED_TO_INT( decoder.builder.advance.x );        t1glyph->linearHoriAdvance =          FIXED_TO_INT( decoder.builder.advance.x );        t1glyph->internal->glyph_transformed = 0;        if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )        {          /* make up vertical ones */          metrics->vertAdvance = ( face->type1.font_bbox.yMax -                                   face->type1.font_bbox.yMin ) >> 16;          t1glyph->linearVertAdvance = metrics->vertAdvance;        }        else        {          metrics->vertAdvance =            FIXED_TO_INT( decoder.builder.advance.y );          t1glyph->linearVertAdvance =            FIXED_TO_INT( decoder.builder.advance.y );        }        t1glyph->format = FT_GLYPH_FORMAT_OUTLINE;        if ( t1size && t1size->metrics.y_ppem < 24 )          t1glyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;#if 1        /* apply the font matrix, if any */        if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||             font_matrix.xy != 0        || font_matrix.yx != 0        )        {          FT_Outline_Transform( &t1glyph->outline, &font_matrix );          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,                                            font_matrix.xx );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,                                            font_matrix.yy );        }        if ( font_offset.x || font_offset.y )        {          FT_Outline_Translate( &t1glyph->outline,                                font_offset.x,                                font_offset.y );          metrics->horiAdvance += font_offset.x;          metrics->vertAdvance += font_offset.y;        }#endif        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )        {          /* scale the outline and the metrics */          FT_Int       n;          FT_Outline*  cur = decoder.builder.base;          FT_Vector*   vec = cur->points;          FT_Fixed     x_scale = glyph->x_scale;          FT_Fixed     y_scale = glyph->y_scale;          /* First of all, scale the points, if we are not hinting */          if ( !hinting || ! decoder.builder.hints_funcs )            for ( n = cur->n_points; n > 0; n--, vec++ )            {              vec->x = FT_MulFix( vec->x, x_scale );              vec->y = FT_MulFix( vec->y, y_scale );            }          /* Then scale the metrics */          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );        }        /* compute the other metrics */        FT_Outline_Get_CBox( &t1glyph->outline, &cbox );        metrics->width  = cbox.xMax - cbox.xMin;        metrics->height = cbox.yMax - cbox.yMin;        metrics->horiBearingX = cbox.xMin;        metrics->horiBearingY = cbox.yMax;        if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )        {          /* make up vertical ones */          ft_synthesize_vertical_metrics( metrics,                                          metrics->vertAdvance );        }      }

//.........这里部分代码省略.........        globals->standard_horizontal_width = stdHW;        globals->stem_darkening_for_ppem   = face->size->metrics.x_ppem;        globals->darken_y                  = af_fixedToInt( darken_y );        /*         * Scale outlines down on the Y-axis to keep them inside their blue         * zones.  The stronger the emboldening, the stronger the         * downscaling (plus heuristical padding to prevent outlines still         * falling out their zones due to rounding).         *         * Reason: `FT_Outline_Embolden' works by shifting the rightmost         * points of stems farther to the right, and topmost points farther         * up.  This positions points on the Y-axis outside their         * pre-computed blue zones and leads to distortion when applying the         * hints in the code further below.  Code outside this emboldening         * block doesn't know we are presenting it with modified outlines         * the analyzer didn't see!         *         * An unfortunate side effect of downscaling is that the emboldening         * effect is slightly decreased.  The loss becomes more pronounced         * versus the CFF driver at smaller sizes, e.g., at 9ppem and below.         */        globals->scale_down_factor =          FT_DivFix( em_size - ( darken_by_font_units_y + af_intToFixed( 8 ) ),                     em_size );      }      FT_Outline_EmboldenXY( &slot->outline,                             globals->darken_x,                             globals->darken_y );      scale_down_matrix.yy = globals->scale_down_factor;      FT_Outline_Transform( &slot->outline, &scale_down_matrix );    }  After_Emboldening:    loader->transformed = internal->glyph_transformed;    if ( loader->transformed )    {      FT_Matrix  inverse;      loader->trans_matrix = internal->glyph_matrix;      loader->trans_delta  = internal->glyph_delta;      inverse = loader->trans_matrix;      if ( !FT_Matrix_Invert( &inverse ) )        FT_Vector_Transform( &loader->trans_delta, &inverse );    }    switch ( slot->format )    {    case FT_GLYPH_FORMAT_OUTLINE:      /* translate the loaded glyph when an internal transform is needed */      if ( loader->transformed )        FT_Outline_Translate( &slot->outline,                              loader->trans_delta.x,                              loader->trans_delta.y );      /* compute original horizontal phantom points (and ignore */      /* vertical ones)                                         */      loader->pp1.x = hints->x_delta;      loader->pp1.y = hints->y_delta;      loader->pp2.x = FT_MulFix( slot->metrics.horiAdvance,                                 hints->x_scale ) + hints->x_delta;