freetype2显示对齐

peeweek

#include
#include
#include "gb2312.h"
#include "freetype2.h"
static struct{
char szFontName[64];
char szFontFile[128];
}FontInfo[] = {
{ "楷体", "./simkai.ttf"   },
{ "黑体", "./simhei.ttf"   },
{ "宋体", "./simsun.ttc"  },
{ "Uming", "./uming.ttf"  }
};
static char* GetFontFile(char *pszFontName)
{
int i;
int nSize;

if((NULL == pszFontName) || ('\0' == *pszFontName))
  goto err;

nSize = sizeof(FontInfo) / sizeof(FontInfo[0]);

for(i=0; i
BOOL FreeType2_InitFont(PFREETYPE2FONT pFont, char *pszName)
{
char *pszFontFile;
FT_Error err;
if((NULL == pFont) || (NULL == pszName) || ('\0' == *pszName))
  return FALSE;
pszFontFile = GetFontFile(pszName);
if(NULL == pszFontFile)
  return FALSE;
err = FT_Init_FreeType(&pFont->library);
if(err != FT_Err_Ok)
{
  printf("InitFont->FT_InitFreeType error: %d\n", err);
  pFont->library = NULL;
  return FALSE;
}
err = FT_New_Face(pFont->library, pszFontFile, 0, &pFont->face);
if(err != FT_Err_Ok)
{
  printf("InitFont->FT_New_Face error: %d\n", err);
  FT_Done_FreeType(pFont->library);
  pFont->library = NULL;
  pFont->face = NULL;
  return FALSE;
}
err = FT_Set_Char_Size(pFont->face, 0, 64 FT_Set_Char_Size error: %d\n", err);
  FT_Done_Face(pFont->face);
  FT_Done_FreeType(pFont->library);
  pFont->library = NULL;
  pFont->face = NULL;
  return FALSE;
}
pFont->pucData = NULL;
return TRUE;
}
BOOL FreeType2_DestroyFont(PFREETYPE2FONT pFont)
{
if(NULL == pFont)
  return FALSE;
if(pFont->face != NULL)
  FT_Done_Face(pFont->face);
if(pFont->library != NULL)
  FT_Done_FreeType(pFont->library);
pFont->face = NULL;
pFont->library = NULL;
if(pFont->pucData != NULL)
  free(pFont->pucData);
  
pFont->pucData = NULL;
return TRUE;
}
BOOL FreeType2_SetFontSize(PFREETYPE2FONT pFont, int nWid, int nHei)
{
FT_Error err;
if((NULL == pFont) || (NULL == pFont->face))
  return FALSE;
err = FT_Set_Pixel_Sizes(pFont->face, nWid, nHei);
if(err != FT_Err_Ok)
{
  printf("SetFontSize->FT_Set_Pixel_Sizes error: %d\n", err);
  return FALSE;
}
return TRUE;
}
static unsigned short s_font_utf8_to_unicode (const unsigned char *utf8)
{
unsigned short unicode;
unicode = utf8[0];
if (unicode >= 0xF0) {
  unicode  =  (unsigned short) (utf8[0] & 0x07) = 0xE0) {
  unicode  =  (unsigned short) (utf8[0] & 0x0F) = 0xC0) {
  unicode  =  (unsigned short) (utf8[0] & 0x1F)
return unicode;
}
BOOL FreeType2_GetFontChar(FT_Face face, char *pszText, PXGlyph pXGlyph, BOOL bFlag)
{
unsigned short unicode;
FT_UInt index;
FT_BBox bbox;
FT_Error err;
FT_Vector origin;
FT_Glyph glyph;

if((NULL == face) || (NULL == pszText) || ('\0' == *pszText) || (NULL == pXGlyph))
  return FALSE;

memset((void*)pXGlyph, 0, sizeof(XGlyph));

if(*pszText & 0x80)
  unicode = gb2312_0_conv_to_uc32(pszText);
else
  unicode = s_font_utf8_to_unicode(pszText);
index = FT_Get_Char_Index(face, unicode);
if(!index)
{
  printf("FreeType2_GetFontChar->FT_Get_Char_Index fail: index=0 !\n");
  return FALSE;
}
err = FT_Load_Glyph(face, index, FT_LOAD_DEFAULT);
if(err)
{
  printf("FreeType2_GetFontChar->FT_Load_Glyph fail !\n");
  return FALSE;
}
err = FT_Get_Glyph(face->glyph, &glyph);
if(err)
{
  printf("FreeType2_GetFontChar->FT_Get_Glyph fail !\n");
  return FALSE;
}
FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_gridfit, &bbox);

origin.x = -bbox.xMin;
origin.y = -bbox.yMin;

if(FT_IS_SCALABLE(face))
{
  err = FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, &origin, 1);
  if(err)
  {
   FT_Done_Glyph(glyph);
   printf("FreeType2_GetFontChar->FT_Glyph_To_Bitmap fail !\n");
   return FALSE;
  }
  
  else
  {
   int nSize;
   FT_Bitmap bm = ((FT_BitmapGlyph)glyph)->bitmap;
   nSize = bm.pitch * bm.rows;
   if(nSize > 0)
   {
    if(bFlag)
    {
     pXGlyph->pucData = (unsigned char*)calloc(nSize, sizeof(unsigned char));
     if(NULL == pXGlyph->pucData)
     {
      FT_Done_Glyph(glyph);
      printf("FreeType2_GetFontChar->calloc unsigned char fail !\n");
      return FALSE;
     }
     memcpy((void*)pXGlyph->pucData, (void*)bm.buffer, nSize);
    }
    pXGlyph->nWid = bm.width;
    pXGlyph->nHei = bm.rows;
    pXGlyph->nLineStep = bm.pitch;   
    pXGlyph->nBearingx = face->glyph->metrics.horiBearingX / 64;
    pXGlyph->nBearingy = face->glyph->metrics.horiBearingY / 64;
    pXGlyph->nAdvance = face->glyph->metrics.horiAdvance / 64;
   }
  }
}

FT_Done_Glyph(glyph);
return TRUE;
}
BOOL FreeType2_GetFontData(PFREETYPE2FONT pFont, char *pText)
{
int i;
int j;
int n;
int x;
int y;
int pen_x;
int pen_y;
int num_chars;
int xmin;
int xmax;
int glyph_min_x = 0;
FT_UInt previous;
FT_UInt glyph_index;
FT_UInt num_glyphs;
FT_UInt glyph_advance_x;
FT_BBox bbox;
FT_Error Error;
FT_Glyph glyph;
FT_Bool use_kerning;
FT_BBox glyph_bbox;
FT_BitmapGlyph bit;

unsigned short *unicode;
char *pszTemp = NULL;
FT_Vector *pos;
FT_Vector *pens;
PIMAGE pImage;
if((NULL == pFont) || (NULL == pFont->face) || (NULL == pText) || '\0' == *pText)
  return FALSE;
for(num_chars=0,pszTemp=pText; *pszTemp!='\0'; )
{
  if(*pszTemp & 0x80)
   pszTemp += 2;
  else
   pszTemp++;
  num_chars++;
}

pos = (FT_Vector*)calloc(num_chars, sizeof(FT_Vector));
if(NULL == pos)
{
  printf("FreeType2_GetFontData->calloc FT_Vector pos fail !\n");
  return FALSE;
}

pens = (FT_Vector*)calloc(num_chars, sizeof(FT_Vector));
if(NULL == pens)
{
  free(pos);
  printf("FreeType2_GetFontData->calloc FT_Vector pens fail !\n");
  return FALSE;
}

pImage = (PIMAGE)calloc(num_chars, sizeof(IMAGE));
if(NULL == pImage)
{
  free(pos);
  free(pens);
  printf("FreeType2_GetFontData->calloc IMAGE fail !\n");
  return FALSE;
}

unicode = (unsigned short*)calloc(num_chars, sizeof(unsigned short));
if(NULL == unicode)
{
  free(pos);
  free(pens);
  free(pImage);
  printf("FreeType2_GetFontData->calloc unsigned short fail !\n");
  return FALSE;
}
for(i=0,pszTemp=pText; *pszTemp!='\0'; i++)
{
  if(*pszTemp & 0x80)
  {
   unicode = gb2312_0_conv_to_uc32(pszTemp);
   pszTemp += 2;
  }
  else
  {
   unicode = s_font_utf8_to_unicode(pszTemp);
   pszTemp++;
  }
}

pen_x = 0;
pen_y = 0;
previous = 0;
num_glyphs = 0;
use_kerning = FT_HAS_KERNING(pFont->face);

bbox.xMin = 32000;
bbox.yMin = 32000;
bbox.xMax = -32000;
bbox.yMax = -32000;

xmin = 3200;
xmax = -3200;

x = 0;
y = 0;

for(i=0; iface, unicode);
  if(!glyph_index)
   continue;
   
  if(use_kerning && previous && glyph_index)
  {
   FT_Vector delta;
   
   Error = FT_Get_Kerning(pFont->face, previous, glyph_index, FT_KERNING_DEFAULT, &delta);
   if(Error)
    continue;
   
   pen_x += delta.x >> 6;
  }
  
  Error = FT_Load_Glyph(pFont->face, glyph_index, FT_LOAD_DEFAULT);
  if(Error)
   continue;
  
  Error = FT_Get_Glyph(pFont->face->glyph, &glyph);
  if(Error)
   continue;
  Error = FT_Glyph_To_Bitmap(&glyph, ft_render_mode_normal, 0, 1);
  if(Error)
   continue;
  
  FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_pixels, &glyph_bbox);
  glyph_min_x = FT_FLOOR(pFont->face->glyph->metrics.horiBearingX);
  glyph_advance_x = FT_CEIL(pFont->face->glyph->metrics.horiAdvance);
  pos[num_glyphs].x = pen_x;
  pos[num_glyphs].y = pen_y;
  pen_x += glyph_advance_x;
  
  glyph_bbox.xMin += pen_x;
  glyph_bbox.xMax += pen_x;
  glyph_bbox.yMin += pen_y;
  glyph_bbox.yMax += pen_y;
  
  if(glyph_bbox.xMin  bbox.xMax)
   bbox.xMax = glyph_bbox.xMax;
  
  if(glyph_bbox.yMax > bbox.yMax)
   bbox.yMax = glyph_bbox.yMax;
   
  bit = (FT_BitmapGlyph)glyph;
  
  pens[num_glyphs].x = pos[num_glyphs].x;
  pens[num_glyphs].y = pos[num_glyphs].y;
  
  x = pens[num_glyphs].x;
  xmin = MIN(xmin, x);
  xmax = MAX(xmax, x + bit->bitmap.width + glyph_min_x);
  pImage[num_glyphs].image = glyph;
  pImage[num_glyphs].min_x = glyph_min_x;
  pImage[num_glyphs].advance_x = glyph_advance_x;
  
  previous = glyph_index;
  num_glyphs++;
}

if(xmin > xmax)
{
  xmin = 0;
  xmax = 0;
}

if(bbox.xMin > bbox.xMax)
{
  bbox.xMin = 0;
  bbox.yMin = 0;
  bbox.xMax = 0;
  bbox.yMax = 0;
}

pFont->nWid = xmax - xmin;
pFont->nHei = bbox.yMax - bbox.yMin;

pFont->pucData = (unsigned char*)calloc(pFont->nWid*pFont->nHei, sizeof(unsigned char));
if(NULL == pFont->pucData)
{
  free(pos);
  free(pens);
  free(unicode);
  free(pImage);
  printf("FreeType2_GetFontData->calloc unsigned char fail !\n");
  return FALSE;  
}

for(n=0; ntop + bbox.yMax;
  
  pucBuf = bit->bitmap.buffer;
  
  start = pFont->pucData;
  pucBmp = start + (x + y*pFont->nWid);
  end = start + pFont->nWid*pFont->nHei;
  
  for(i=0; ibitmap.rows; i++)
  {
   for(j=0; jbitmap.width; j++)
   {
    if(*pucBuf && (pucBmp >= start) && (pucBmp bitmap.pitch - bit->bitmap.width);
   pucBmp += (pFont->nWid - bit->bitmap.width);
  }
  
  FT_Done_Glyph(pImage[n].image);
}

free(pos);
free(pens);
free(unicode);
free(pImage);

return TRUE;
}

int FreeType2_GetHeigh(PFREETYPE2FONT pFont)
{
if(NULL == pFont)
  return 0;
return pFont->nHei;
}


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u3/96685/showart_2114562.html