core/ difference with XFA (for information only).

core/src/fxge/ge/fx_ge_fontmap.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 <limits>
 
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxge/fx_freetype.h"
@@ skipping 40 matching lines @@
       FXFT_Done_Face(m_SingleFace.m_pFace);
     }
   } else if (m_Type == 2) {
     for (int i = 0; i < 16; i++)
       if (m_TTCFace.m_pFaces[i]) {
         FXFT_Done_Face(m_TTCFace.m_pFaces[i]);
       }
   }
   FX_Free(m_pFontData);
 }
+#ifndef PDF_ENABLE_XFA
 FX_BOOL CTTFontDesc::ReleaseFace(FXFT_Face face) {
+#else
+int32_t CTTFontDesc::ReleaseFace(FXFT_Face face) {
+#endif
   if (m_Type == 1) {
     if (m_SingleFace.m_pFace != face) {
+#ifndef PDF_ENABLE_XFA
       return FALSE;
+#else
+      return -1;
+#endif
     }
   } else if (m_Type == 2) {
     int i;
     for (i = 0; i < 16; i++)
       if (m_TTCFace.m_pFaces[i] == face) {
         break;
       }
     if (i == 16) {
+#ifndef PDF_ENABLE_XFA
       return FALSE;
+#else
+      return -1;
+#endif
     }
   }
   m_RefCount--;
   if (m_RefCount) {
+#ifndef PDF_ENABLE_XFA
     return FALSE;
+#else
+    return m_RefCount;
+#endif
   }
   delete this;
+#ifndef PDF_ENABLE_XFA
   return TRUE;
+#else
+  return 0;
+#endif
 }
 
 CFX_FontMgr::CFX_FontMgr() : m_FTLibrary(nullptr) {
   m_pBuiltinMapper.reset(new CFX_FontMapper(this));
 }
 
 CFX_FontMgr::~CFX_FontMgr() {
   for (const auto& pair : m_FaceMap)
     delete pair.second;
 
@@ skipping 258 matching lines @@
   FXFT_Face face = nullptr;
   if (FXFT_New_Face(library, filename, face_index, &face))
     return nullptr;
   return FXFT_Set_Pixel_Sizes(face, 64, 64) ? nullptr : face;
 }
 
 void CFX_FontMgr::ReleaseFace(FXFT_Face face) {
   if (!face) {
     return;
   }
+#ifdef PDF_ENABLE_XFA
+  FX_BOOL bNeedFaceDone = TRUE;
+#endif
   auto it = m_FaceMap.begin();
   while (it != m_FaceMap.end()) {
     auto temp = it++;
+#ifndef PDF_ENABLE_XFA
     if (temp->second->ReleaseFace(face)) {
+#else
+    int nRet = temp->second->ReleaseFace(face);
+    if (nRet == 0) {
+#endif
       m_FaceMap.erase(temp);
+#ifdef PDF_ENABLE_XFA
+      bNeedFaceDone = FALSE;
+    } else if (nRet > 0) {
+      bNeedFaceDone = FALSE;
+#endif
     }
   }
+#ifdef PDF_ENABLE_XFA
+  if (bNeedFaceDone && !m_pBuiltinMapper->IsBuiltinFace(face)) {
+    FXFT_Done_Face(face);
+  }
+#endif
 }
 const FoxitFonts g_FoxitFonts[14] = {
     {g_FoxitFixedFontData, 17597},
     {g_FoxitFixedBoldFontData, 18055},
     {g_FoxitFixedBoldItalicFontData, 19151},
     {g_FoxitFixedItalicFontData, 18746},
     {g_FoxitSansFontData, 15025},
     {g_FoxitSansBoldFontData, 16344},
     {g_FoxitSansBoldItalicFontData, 16418},
     {g_FoxitSansItalicFontData, 16339},
@@ skipping 29 matching lines @@
 CFX_FontMapper::CFX_FontMapper(CFX_FontMgr* mgr)
     : m_bListLoaded(FALSE),
       m_pFontInfo(nullptr),
       m_pFontEnumerator(nullptr),
       m_pFontMgr(mgr) {
   m_MMFaces[0] = nullptr;
   m_MMFaces[1] = nullptr;
   FXSYS_memset(m_FoxitFaces, 0, sizeof(m_FoxitFaces));
 }
 CFX_FontMapper::~CFX_FontMapper() {
+#ifndef PDF_ENABLE_XFA
   for (size_t i = 0; i < FX_ArraySize(m_FoxitFaces); ++i) {
     if (m_FoxitFaces[i])
+#else
+  for (int i = 0; i < 14; i++)
+    if (m_FoxitFaces[i]) {
+#endif
       FXFT_Done_Face(m_FoxitFaces[i]);
+#ifndef PDF_ENABLE_XFA
   }
+#else
+    }
+#endif
   if (m_MMFaces[0]) {
     FXFT_Done_Face(m_MMFaces[0]);
   }
   if (m_MMFaces[1]) {
     FXFT_Done_Face(m_MMFaces[1]);
   }
   if (m_pFontInfo) {
     m_pFontInfo->Release();
   }
 }
@@ skipping 618 matching lines @@
       bItalic = TRUE;
     }
   }
   iExact = !match.IsEmpty();
   void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily,
                                      family, iExact);
   if (iExact) {
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
   }
   if (hFont == NULL) {
+#ifdef PDF_ENABLE_XFA
+    if (flags & FXFONT_EXACTMATCH) {
+      return NULL;
+    }
+#endif
     if (bCJK) {
       if (italic_angle != 0) {
         bItalic = TRUE;
       } else {
         bItalic = FALSE;
       }
       weight = old_weight;
     }
     if (!match.IsEmpty()) {
       hFont = m_pFontInfo->GetFont(match);
@@ skipping 105 matching lines @@
     if (italic_angle == 0) {
       italic_angle = -12;
     } else if (FXSYS_abs(italic_angle) < 5) {
       italic_angle = 0;
     }
     pSubstFont->m_ItalicAngle = italic_angle;
   }
   m_pFontInfo->DeleteFont(hFont);
   return face;
 }
+#ifdef PDF_ENABLE_XFA
+FXFT_Face CFX_FontMapper::FindSubstFontByUnicode(FX_DWORD dwUnicode,
+                                                 FX_DWORD flags,
+                                                 int weight,
+                                                 int italic_angle) {
+  if (m_pFontInfo == NULL) {
+    return NULL;
+  }
+  FX_BOOL bItalic = (flags & FXFONT_ITALIC) != 0;
+  int PitchFamily = 0;
+  if (flags & FXFONT_SERIF) {
+    PitchFamily |= FXFONT_FF_ROMAN;
+  }
+  if (flags & FXFONT_SCRIPT) {
+    PitchFamily |= FXFONT_FF_SCRIPT;
+  }
+  if (flags & FXFONT_FIXED_PITCH) {
+    PitchFamily |= FXFONT_FF_FIXEDPITCH;
+  }
+  void* hFont =
+      m_pFontInfo->MapFontByUnicode(dwUnicode, weight, bItalic, PitchFamily);
+  if (hFont == NULL) {
+    return NULL;
+  }
+  FX_DWORD ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, NULL, 0);
+  FX_DWORD font_size = m_pFontInfo->GetFontData(hFont, 0, NULL, 0);
+  if (font_size == 0 && ttc_size == 0) {
+    m_pFontInfo->DeleteFont(hFont);
+    return NULL;
+  }
+  FXFT_Face face = NULL;
+  if (ttc_size) {
+    uint8_t temp[1024];
+    m_pFontInfo->GetFontData(hFont, 0x74746366, temp, 1024);
+    FX_DWORD checksum = 0;
+    for (int i = 0; i < 256; i++) {
+      checksum += ((FX_DWORD*)temp)[i];
+    }
+    uint8_t* pFontData;
+    face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum,
+                                        ttc_size - font_size, pFontData);
+    if (face == NULL) {
+      pFontData = FX_Alloc(uint8_t, ttc_size);
+      if (pFontData) {
+        m_pFontInfo->GetFontData(hFont, 0x74746366, pFontData, ttc_size);
+        face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData,
+                                            ttc_size, ttc_size - font_size);
+      }
+    }
+  } else {
+    CFX_ByteString SubstName;
+    m_pFontInfo->GetFaceName(hFont, SubstName);
+    uint8_t* pFontData;
+    face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
+    if (face == NULL) {
+      pFontData = FX_Alloc(uint8_t, font_size);
+      if (!pFontData) {
+        m_pFontInfo->DeleteFont(hFont);
+        return NULL;
+      }
+      m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
+      face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
+                                       font_size,
+                                       m_pFontInfo->GetFaceIndex(hFont));
+    }
+  }
+  m_pFontInfo->DeleteFont(hFont);
+  return face;
+}
+
+FX_BOOL CFX_FontMapper::IsBuiltinFace(const FXFT_Face face) const {
+  for (int i = 0; i < MM_FACE_COUNT; ++i) {
+    if (m_MMFaces[i] == face) {
+      return TRUE;
+    }
+  }
+  for (int i = 0; i < FOXIT_FACE_COUNT; ++i) {
+    if (m_FoxitFaces[i] == face) {
+      return TRUE;
+    }
+  }
+  return FALSE;
+}
+#endif
 extern "C" {
 unsigned long _FTStreamRead(FXFT_Stream stream,
                             unsigned long offset,
                             unsigned char* buffer,
                             unsigned long count);
 void _FTStreamClose(FXFT_Stream stream);
 };
 CFontFileFaceInfo::CFontFileFaceInfo() {
   m_pFile = NULL;
   m_Face = NULL;
@@ skipping 274 matching lines @@
   return pFind;
 }
 void* CFX_FolderFontInfo::MapFont(int weight,
                                   FX_BOOL bItalic,
                                   int charset,
                                   int pitch_family,
                                   const FX_CHAR* family,
                                   int& iExact) {
   return NULL;
 }
+#ifdef PDF_ENABLE_XFA
+void* CFX_FolderFontInfo::MapFontByUnicode(FX_DWORD dwUnicode,
+                                           int weight,
+                                           FX_BOOL bItalic,
+                                           int pitch_family) {
+  return NULL;
+}
+#endif
 void* CFX_FolderFontInfo::GetFont(const FX_CHAR* face) {
   auto it = m_FontList.find(face);
   return it != m_FontList.end() ? it->second : nullptr;
 }
 FX_DWORD CFX_FolderFontInfo::GetFontData(void* hFont,
                                          FX_DWORD table,
                                          uint8_t* buffer,
                                          FX_DWORD size) {
   if (hFont == NULL) {
     return 0;
@@ skipping 47 matching lines @@
 int PDF_GetStandardFontName(CFX_ByteString* name) {
   AltFontName* found = static_cast<AltFontName*>(
       FXSYS_bsearch(name->c_str(), g_AltFontNames, FX_ArraySize(g_AltFontNames),
                     sizeof(AltFontName), compareString));
   if (!found)
     return -1;
 
   *name = g_Base14FontNames[found->m_Index];
   return found->m_Index;
 }