Use system FreeType

core/src/fxge/ge/fx_ge_text.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxge/fx_freetype.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "text_int.h"
@@ skipping 1314 matching lines @@
             if (pFont->IsVertical()) {
                 ft_matrix.yx += ft_matrix.yy * skew / 100;
             } else {
                 ft_matrix.xy += -ft_matrix.xx * skew / 100;
             }
         }
         if (pSubstFont->m_SubstFlags & FXFONT_SUBST_MM) {
             pFont->AdjustMMParams(glyph_index, dest_width, pFont->GetSubstFont()->m_Weight);
         }
     }
-    int transflag = FXFT_Get_Face_Internal_Flag(m_Face);
     FXFT_Set_Transform(m_Face, &ft_matrix, 0);
     int load_flags = (m_Face->face_flags & FT_FACE_FLAG_SFNT) ? FXFT_LOAD_NO_BITMAP : (FXFT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING);
     int error = FXFT_Load_Glyph(m_Face, glyph_index, load_flags);
     if (error) {
-        FXFT_Set_Face_Internal_Flag(m_Face, transflag);
         return NULL;
     }
     int weight = 0;
     if (bUseCJKSubFont) {
         weight = pSubstFont->m_WeightCJK;
     } else {
         weight = pSubstFont ? pSubstFont->m_Weight : 0;
     }
     if (pSubstFont && !(pSubstFont->m_SubstFlags & FXFONT_SUBST_MM) && weight > 400) {
         int index = (weight - 400) / 10;
         if (index >= WEIGHTPOW_ARRAY_SIZE) {
-            FXFT_Set_Face_Internal_Flag(m_Face, transflag);
             return NULL;
         }
         int level = 0;
         if (pSubstFont->m_Charset == FXFONT_SHIFTJIS_CHARSET) {
             level = g_WeightPow_SHIFTJIS[index] * 2 * (FXSYS_abs((int)(ft_matrix.xx)) + FXSYS_abs((int)(ft_matrix.xy))) / 36655;
         } else {
             level = g_WeightPow_11[index] * (FXSYS_abs((int)(ft_matrix.xx)) + FXSYS_abs((int)(ft_matrix.xy))) / 36655;
         }
         FXFT_Outline_Embolden(FXFT_Get_Glyph_Outline(m_Face), level);
     }
     FXFT_Library_SetLcdFilter(CFX_GEModule::Get()->GetFontMgr()->m_FTLibrary, FT_LCD_FILTER_DEFAULT);
     error = FXFT_Render_Glyph(m_Face, anti_alias);
     if (error) {
-        FXFT_Set_Face_Internal_Flag(m_Face, transflag);
         return NULL;
     }
     int bmwidth = FXFT_Get_Bitmap_Width(FXFT_Get_Glyph_Bitmap(m_Face));
     int bmheight = FXFT_Get_Bitmap_Rows(FXFT_Get_Glyph_Bitmap(m_Face));
     if (bmwidth > 2048 || bmheight > 2048) {
-        FXFT_Set_Face_Internal_Flag(m_Face, transflag);
         return NULL;
     }
     int dib_width = bmwidth;
     CFX_GlyphBitmap* pGlyphBitmap = FX_NEW CFX_GlyphBitmap;
     if (!pGlyphBitmap) {
         return NULL;
     }
     pGlyphBitmap->m_Bitmap.Create(dib_width, bmheight,
                                   anti_alias == FXFT_RENDER_MODE_MONO ? FXDIB_1bppMask : FXDIB_8bppMask);
     pGlyphBitmap->m_Left = FXFT_Get_Glyph_BitmapLeft(m_Face);
@@ skipping 16 matching lines @@
         if (anti_alias == FXFT_RENDER_MODE_MONO && FXFT_Get_Bitmap_PixelMode(FXFT_Get_Glyph_Bitmap(m_Face)) == FXFT_PIXEL_MODE_MONO) {
             int rowbytes = FXSYS_abs(src_pitch) > dest_pitch ? dest_pitch : FXSYS_abs(src_pitch);
             for (int row = 0; row < bmheight; row ++) {
                 FXSYS_memcpy32(pDestBuf + row * dest_pitch, pSrcBuf + row * src_pitch, rowbytes);
             }
         } else {
             _ContrastAdjust(pSrcBuf, pDestBuf, bmwidth, bmheight, src_pitch, dest_pitch);
             _GammaAdjust(pDestBuf, bmwidth, bmheight, dest_pitch, CFX_GEModule::Get()->GetTextGammaTable());
         }
     }
-    FXFT_Set_Face_Internal_Flag(m_Face, transflag);
     return pGlyphBitmap;
 }
 FX_BOOL _OutputGlyph(void* dib, int x, int y, CFX_Font* pFont,
                      int glyph_index, FX_ARGB argb)
 {
     CFX_DIBitmap* pDib = (CFX_DIBitmap*)dib;
     FXFT_Face face = pFont->GetFace();
     int error = FXFT_Load_Glyph(face, glyph_index, FXFT_LOAD_NO_BITMAP);
     if (error) {
         return FALSE;
@@ skipping 21 matching lines @@
     return TRUE;
 }
 FX_BOOL OutputText(void* dib, int x, int y, CFX_Font* pFont, double font_size,
                    CFX_AffineMatrix* pText_matrix, unsigned short const* text, unsigned long argb)
 {
     if (!pFont) {
         return FALSE;
     }
     FXFT_Face face = pFont->GetFace();
     FXFT_Select_Charmap(pFont->m_Face, FXFT_ENCODING_UNICODE);
-    int transflag = FXFT_Get_Face_Internal_Flag(pFont->m_Face);
     if (pText_matrix) {
         FXFT_Matrix  ft_matrix;
         ft_matrix.xx = (signed long)(pText_matrix->a / 64 * 65536);
         ft_matrix.xy = (signed long)(pText_matrix->c / 64 * 65536);
         ft_matrix.yx = (signed long)(pText_matrix->b / 64 * 65536);
         ft_matrix.yy = (signed long)(pText_matrix->d / 64 * 65536);
         FXFT_Set_Transform(face, &ft_matrix, 0);
     }
     FX_FLOAT x_pos = 0;
     for (; *text != 0; text ++) {
         FX_WCHAR unicode = *text;
         int glyph_index = FXFT_Get_Char_Index(pFont->m_Face, unicode);
         if (glyph_index <= 0) {
             continue;
         }
         int err = FXFT_Load_Glyph(pFont->m_Face, glyph_index, FXFT_LOAD_NO_SCALE | FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
         if (err) {
             continue;
         }
         int w = FXFT_Get_Glyph_HoriAdvance(pFont->m_Face);
         int em = FXFT_Get_Face_UnitsPerEM(pFont->m_Face);
         FX_FLOAT x1, y1;
         pText_matrix->Transform(x_pos, 0, x1, y1);
         _OutputGlyph(dib, (int)x1 + x, (int) - y1 + y, pFont,
                      glyph_index, argb);
         x_pos += (FX_FLOAT)w / em;
     }
-    FXFT_Set_Face_Internal_Flag(pFont->m_Face, transflag);
     return TRUE;
 }
 FX_BOOL OutputGlyph(void* dib, int x, int y, CFX_Font* pFont, double font_size,
                     CFX_AffineMatrix* pMatrix, unsigned long glyph_index, unsigned long argb)
 {
     FXFT_Matrix  ft_matrix;
     if (pMatrix) {
         ft_matrix.xx = (signed long)(pMatrix->a * font_size / 64 * 65536);
         ft_matrix.xy = (signed long)(pMatrix->c * font_size / 64 * 65536);
         ft_matrix.yx = (signed long)(pMatrix->b * font_size / 64 * 65536);
         ft_matrix.yy = (signed long)(pMatrix->d * font_size / 64 * 65536);
     } else {
         ft_matrix.xx = (signed long)(font_size / 64 * 65536);
         ft_matrix.xy = ft_matrix.yx = 0;
         ft_matrix.yy = (signed long)(font_size / 64 * 65536);
     }
-    int transflag = FXFT_Get_Face_Internal_Flag(pFont->m_Face);
     FXFT_Set_Transform(pFont->m_Face, &ft_matrix, 0);
     FX_BOOL ret = _OutputGlyph(dib, x, y, pFont,
                                glyph_index, argb);
-    FXFT_Set_Face_Internal_Flag(pFont->m_Face, transflag);
     return ret;
 }
 const CFX_PathData* CFX_FaceCache::LoadGlyphPath(CFX_Font* pFont, FX_DWORD glyph_index, int dest_width)
 {
     if (m_Face == NULL || glyph_index == (FX_DWORD) - 1) {
         return NULL;
     }
     CFX_PathData* pGlyphPath = NULL;
     FX_LPVOID key;
     if (pFont->GetSubstFont())
@@ skipping 126 matching lines @@
             if (m_bVertical) {
                 ft_matrix.yx += ft_matrix.yy * skew / 100;
             } else {
                 ft_matrix.xy += -ft_matrix.xx * skew / 100;
             }
         }
         if (m_pSubstFont->m_SubstFlags & FXFONT_SUBST_MM) {
             AdjustMMParams(glyph_index, dest_width, m_pSubstFont->m_Weight);
         }
     }
-    int transflag = FXFT_Get_Face_Internal_Flag(m_Face);
     FXFT_Set_Transform(m_Face, &ft_matrix, 0);
     int load_flags = (m_Face->face_flags & FT_FACE_FLAG_SFNT) ? FXFT_LOAD_NO_BITMAP : FXFT_LOAD_NO_BITMAP | FT_LOAD_NO_HINTING;
     int error = FXFT_Load_Glyph(m_Face, glyph_index, load_flags);
     if (error) {
-        FXFT_Set_Face_Internal_Flag(m_Face, transflag);
         return NULL;
     }
     if (m_pSubstFont && !(m_pSubstFont->m_SubstFlags & FXFONT_SUBST_MM) && m_pSubstFont->m_Weight > 400) {
         int index = (m_pSubstFont->m_Weight - 400) / 10;
         if (index >= WEIGHTPOW_ARRAY_SIZE)
             index = WEIGHTPOW_ARRAY_SIZE - 1;
         int level = 0;
         if (m_pSubstFont->m_Charset == FXFONT_SHIFTJIS_CHARSET) {
             level = g_WeightPow_SHIFTJIS[index] * 2 * 65536 / 36655;
         } else {
             level = g_WeightPow[index] * 2;
         }
         FXFT_Outline_Embolden(FXFT_Get_Glyph_Outline(m_Face), level);
     }
     FXFT_Outline_Funcs funcs;
     funcs.move_to = _Outline_MoveTo;
     funcs.line_to = _Outline_LineTo;
     funcs.conic_to = _Outline_ConicTo;
     funcs.cubic_to = _Outline_CubicTo;
     funcs.shift = 0;
     funcs.delta = 0;
     OUTLINE_PARAMS params;
     params.m_bCount = TRUE;
     params.m_PointCount = 0;
     FXFT_Outline_Decompose(FXFT_Get_Glyph_Outline(m_Face), &funcs, &params);
     if (params.m_PointCount == 0) {
-        FXFT_Set_Face_Internal_Flag(m_Face, transflag);
         return NULL;
     }
     CFX_PathData* pPath = FX_NEW CFX_PathData;
     if (!pPath) {
         return NULL;
     }
     pPath->SetPointCount(params.m_PointCount);
     params.m_bCount = FALSE;
     params.m_PointCount = 0;
     params.m_pPoints = pPath->GetPoints();
     params.m_CurX = params.m_CurY = 0;
     params.m_CoordUnit = 64 * 64.0;
     FXFT_Outline_Decompose(FXFT_Get_Glyph_Outline(m_Face), &funcs, &params);
     _Outline_CheckEmptyContour(&params);
     pPath->TrimPoints(params.m_PointCount);
     if (params.m_PointCount) {
         pPath->GetPoints()[params.m_PointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
     }
-    FXFT_Set_Face_Internal_Flag(m_Face, transflag);
     return pPath;
 }
 void _CFX_UniqueKeyGen::Generate(int count, ...)
 {
     va_list argList;
     va_start(argList, count);
     for (int i = 0; i < count; i ++) {
         int p = va_arg(argList, int);
         ((FX_DWORD*)m_Key)[i] = p;
     }
     va_end(argList);
     m_KeyLen = count * sizeof(FX_DWORD);
 }