Replace IFGAS_Font with underlying concrete type

xfa/fgas/font/fgas_stdfontmgr.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 "xfa/fgas/font/fgas_stdfontmgr.h"
 
 #include "core/fxcrt/include/fx_stream.h"
 #include "core/fxge/include/fx_ge.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/font/fgas_fontutils.h"
+#include "xfa/fgas/font/fgas_gefont.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 IFX_FontMgr* IFX_FontMgr::Create(FX_LPEnumAllFonts pEnumerator) {
   return new CFX_StdFontMgrImp(pEnumerator);
 }
 CFX_StdFontMgrImp::CFX_StdFontMgrImp(FX_LPEnumAllFonts pEnumerator)
     : m_pEnumerator(pEnumerator),
       m_FontFaces(),
       m_CPFonts(8),
       m_FamilyFonts(16),
@@ skipping 13 matching lines @@
   m_FamilyFonts.RemoveAll();
   m_UnicodeFonts.RemoveAll();
   m_BufferFonts.RemoveAll();
   m_FileFonts.RemoveAll();
   m_StreamFonts.RemoveAll();
   m_DeriveFonts.RemoveAll();
   for (int32_t i = m_Fonts.GetUpperBound(); i >= 0; i--)
     m_Fonts[i]->Release();
 }
 
-IFX_Font* CFX_StdFontMgrImp::GetDefFontByCodePage(
+CFX_GEFont* CFX_StdFontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   uint32_t dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
-  IFX_Font* pFont = NULL;
+  CFX_GEFont* pFont = NULL;

[dsinclair, 2016/06/02 17:37:39]

nit: nullptr and others.

   if (m_CPFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
   }
   FX_FONTDESCRIPTOR const* pFD;
   if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {

[dsinclair, 2016/06/02 17:37:39]

nit: if (!( ... and drop the == NULL

     if ((pFD = FindFont(NULL, dwFontStyles, TRUE, wCodePage)) == NULL) {
       if ((pFD = FindFont(NULL, dwFontStyles, FALSE, wCodePage)) == NULL)
         return NULL;
     }
   }
   ASSERT(pFD);
-  pFont = IFX_Font::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
+  pFont = CFX_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontFamilyHash(pFD->wsFontFace, dwFontStyles, wCodePage);
     m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
-IFX_Font* CFX_StdFontMgrImp::GetDefFontByCharset(
+CFX_GEFont* CFX_StdFontMgrImp::GetDefFontByCharset(
     uint8_t nCharset,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                               pszFontFamily);
 }
 
-IFX_Font* CFX_StdFontMgrImp::GetDefFontByUnicode(
+CFX_GEFont* CFX_StdFontMgrImp::GetDefFontByUnicode(
     FX_WCHAR wUnicode,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   const FGAS_FONTUSB* pRet = FGAS_GetUnicodeBitField(wUnicode);
   if (pRet->wBitField == 999)
     return nullptr;
 
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, pRet->wBitField);
-  IFX_Font* pFont = nullptr;
+  CFX_GEFont* pFont = nullptr;
   if (m_UnicodeFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont))
     return pFont ? LoadFont(pFont, dwFontStyles, pRet->wCodePage) : nullptr;
 
   FX_FONTDESCRIPTOR const* pFD =
       FindFont(pszFontFamily, dwFontStyles, FALSE, pRet->wCodePage,
                pRet->wBitField, wUnicode);
   if (!pFD && pszFontFamily) {
     pFD = FindFont(nullptr, dwFontStyles, FALSE, pRet->wCodePage,
                    pRet->wBitField, wUnicode);
   }
   if (!pFD)
     return nullptr;
 
   uint16_t wCodePage = FX_GetCodePageFromCharset(pFD->uCharSet);
   const FX_WCHAR* pFontFace = pFD->wsFontFace;
-  pFont = IFX_Font::LoadFont(pFontFace, dwFontStyles, wCodePage, this);
+  pFont = CFX_GEFont::LoadFont(pFontFace, dwFontStyles, wCodePage, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_UnicodeFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
     m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontFamilyHash(pFontFace, dwFontStyles, wCodePage);
     m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return nullptr;
 }
 
-IFX_Font* CFX_StdFontMgrImp::GetDefFontByLanguage(
+CFX_GEFont* CFX_StdFontMgrImp::GetDefFontByLanguage(
     uint16_t wLanguage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage),
                               dwFontStyles, pszFontFamily);
 }
-IFX_Font* CFX_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFontFamily,
-                                      uint32_t dwFontStyles,
-                                      uint16_t wCodePage) {
+CFX_GEFont* CFX_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFontFamily,
+                                        uint32_t dwFontStyles,
+                                        uint16_t wCodePage) {
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage);
-  IFX_Font* pFont = NULL;
+  CFX_GEFont* pFont = NULL;
   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
   }
   FX_FONTDESCRIPTOR const* pFD = NULL;
   if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
     if ((pFD = FindFont(pszFontFamily, dwFontStyles, FALSE, wCodePage)) ==
         NULL) {
       return NULL;
     }
   }
   ASSERT(pFD);
   if (wCodePage == 0xFFFF) {
     wCodePage = FX_GetCodePageFromCharset(pFD->uCharSet);
   }
-  pFont = IFX_Font::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
+  pFont = CFX_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
     m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
-IFX_Font* CFX_StdFontMgrImp::LoadFont(const uint8_t* pBuffer, int32_t iLength) {
+CFX_GEFont* CFX_StdFontMgrImp::LoadFont(const uint8_t* pBuffer,
+                                        int32_t iLength) {
   ASSERT(pBuffer && iLength > 0);
-  IFX_Font* pFont = NULL;
+  CFX_GEFont* pFont = NULL;
   if (m_BufferFonts.Lookup((void*)pBuffer, (void*&)pFont)) {
     if (pFont) {
       return pFont->Retain();
     }
   }
-  pFont = IFX_Font::LoadFont(pBuffer, iLength, this);
+  pFont = CFX_GEFont::LoadFont(pBuffer, iLength, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_BufferFonts.SetAt((void*)pBuffer, pFont);
     return pFont->Retain();
   }
   return NULL;
 }
-IFX_Font* CFX_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFileName) {
+CFX_GEFont* CFX_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFileName) {
   ASSERT(pszFileName);
   uint32_t dwHash = FX_HashCode_GetW(pszFileName, false);
-  IFX_Font* pFont = NULL;
+  CFX_GEFont* pFont = NULL;
   if (m_FileFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     if (pFont) {
       return pFont->Retain();
     }
   }
-  pFont = IFX_Font::LoadFont(pszFileName, NULL);
+  pFont = CFX_GEFont::LoadFont(pszFileName);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_FileFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return pFont->Retain();
   }
   return NULL;
 }
-IFX_Font* CFX_StdFontMgrImp::LoadFont(IFX_Stream* pFontStream,
-                                      const FX_WCHAR* pszFontAlias,
-                                      uint32_t dwFontStyles,
-                                      uint16_t wCodePage,
-                                      FX_BOOL bSaveStream) {
+CFX_GEFont* CFX_StdFontMgrImp::LoadFont(IFX_Stream* pFontStream,
+                                        const FX_WCHAR* pszFontAlias,
+                                        uint32_t dwFontStyles,
+                                        uint16_t wCodePage,
+                                        FX_BOOL bSaveStream) {
   ASSERT(pFontStream && pFontStream->GetLength() > 0);
-  IFX_Font* pFont = NULL;
+  CFX_GEFont* pFont = NULL;
   if (m_StreamFonts.Lookup((void*)pFontStream, (void*&)pFont)) {
     if (pFont) {
       if (pszFontAlias) {
         uint32_t dwHash =
             FGAS_GetFontFamilyHash(pszFontAlias, dwFontStyles, wCodePage);
         m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
       }
       return LoadFont(pFont, dwFontStyles, wCodePage);
     }
   }
-  pFont = IFX_Font::LoadFont(pFontStream, this, bSaveStream);
+  pFont = CFX_GEFont::LoadFont(pFontStream, this, bSaveStream);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_StreamFonts.SetAt((void*)pFontStream, (void*)pFont);
     if (pszFontAlias) {
       uint32_t dwHash =
           FGAS_GetFontFamilyHash(pszFontAlias, dwFontStyles, wCodePage);
       m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     }
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
-IFX_Font* CFX_StdFontMgrImp::LoadFont(IFX_Font* pSrcFont,
-                                      uint32_t dwFontStyles,
-                                      uint16_t wCodePage) {
+CFX_GEFont* CFX_StdFontMgrImp::LoadFont(CFX_GEFont* pSrcFont,
+                                        uint32_t dwFontStyles,
+                                        uint16_t wCodePage) {
   ASSERT(pSrcFont);
   if (pSrcFont->GetFontStyles() == dwFontStyles) {
     return pSrcFont->Retain();
   }
   void* buffer[3] = {pSrcFont, (void*)(uintptr_t)dwFontStyles,
                      (void*)(uintptr_t)wCodePage};
   uint32_t dwHash = FX_HashCode_GetA(
       CFX_ByteStringC((uint8_t*)buffer, sizeof(buffer)), false);
-  IFX_Font* pFont = NULL;
+  CFX_GEFont* pFont = NULL;
   if (m_DeriveFonts.GetCount() > 0) {
     m_DeriveFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont);
     if (pFont) {
       return pFont->Retain();
     }
   }
   pFont = pSrcFont->Derive(dwFontStyles, wCodePage);
   if (pFont) {
     m_DeriveFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     int32_t index = m_Fonts.Find(pFont);
     if (index < 0) {
       m_Fonts.Add(pFont);
       pFont->Retain();
     }
     return pFont;
   }
   return NULL;
 }
 
 void CFX_StdFontMgrImp::ClearFontCache() {
   for (int32_t i = 0; i < m_Fonts.GetSize(); i++)
     m_Fonts[i]->Reset();
 }
 
-void CFX_StdFontMgrImp::RemoveFont(CFX_MapPtrToPtr& fontMap, IFX_Font* pFont) {
+void CFX_StdFontMgrImp::RemoveFont(CFX_MapPtrToPtr& fontMap,
+                                   CFX_GEFont* pFont) {
   FX_POSITION pos = fontMap.GetStartPosition();
   void* pKey;
   void* pFind;
   while (pos) {
     pFind = NULL;
     fontMap.GetNextAssoc(pos, pKey, pFind);
     if (pFind != (void*)pFont) {
       continue;
     }
     fontMap.RemoveKey(pKey);
     break;
   }
 }
-void CFX_StdFontMgrImp::RemoveFont(IFX_Font* pFont) {
+void CFX_StdFontMgrImp::RemoveFont(CFX_GEFont* pFont) {
   RemoveFont(m_CPFonts, pFont);
   RemoveFont(m_FamilyFonts, pFont);
   RemoveFont(m_UnicodeFonts, pFont);
   RemoveFont(m_BufferFonts, pFont);
   RemoveFont(m_FileFonts, pFont);
   RemoveFont(m_StreamFonts, pFont);
   RemoveFont(m_DeriveFonts, pFont);
   int32_t iFind = m_Fonts.Find(pFont);
   if (iFind > -1) {
     m_Fonts.RemoveAt(iFind, 1);
@@ skipping 341 matching lines @@
   FX_POSITION pos = m_Hash2CandidateList.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     delete pDescs;
   }
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
-    CFX_ArrayTemplate<IFX_Font*>* pFonts;
+    CFX_ArrayTemplate<CFX_GEFont*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
     delete pFonts;
   }
   m_Hash2Fonts.RemoveAll();
   pos = m_Hash2FileAccess.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     IFX_FileAccess* pFileAccess;
     m_Hash2FileAccess.GetNextAssoc(pos, dwHash, pFileAccess);
     if (NULL != pFileAccess) {
       pFileAccess->Release();
     }
   }
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
-    IFX_Font* pFont;
+    CFX_GEFont* pFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
     if (NULL != pFont) {
       pFont->Release();
     }
   }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
-    IFX_Font* pFont;
+    CFX_GEFont* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
   delete this;
 }
-IFX_Font* CFX_FontMgrImp::GetDefFontByCodePage(uint16_t wCodePage,
-                                               uint32_t dwFontStyles,
-                                               const FX_WCHAR* pszFontFamily) {
+CFX_GEFont* CFX_FontMgrImp::GetDefFontByCodePage(
+    uint16_t wCodePage,
+    uint32_t dwFontStyles,
+    const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
-IFX_Font* CFX_FontMgrImp::GetDefFontByCharset(uint8_t nCharset,
-                                              uint32_t dwFontStyles,
-                                              const FX_WCHAR* pszFontFamily) {
+CFX_GEFont* CFX_FontMgrImp::GetDefFontByCharset(uint8_t nCharset,
+                                                uint32_t dwFontStyles,
+                                                const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
-IFX_Font* CFX_FontMgrImp::GetDefFontByUnicode(FX_WCHAR wUnicode,
-                                              uint32_t dwFontStyles,
-                                              const FX_WCHAR* pszFontFamily) {
+CFX_GEFont* CFX_FontMgrImp::GetDefFontByUnicode(FX_WCHAR wUnicode,
+                                                uint32_t dwFontStyles,
+                                                const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
-IFX_Font* CFX_FontMgrImp::GetDefFontByLanguage(uint16_t wLanguage,
-                                               uint32_t dwFontStyles,
-                                               const FX_WCHAR* pszFontFamily) {
+CFX_GEFont* CFX_FontMgrImp::GetDefFontByLanguage(
+    uint16_t wLanguage,
+    uint32_t dwFontStyles,
+    const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
 
-IFX_Font* CFX_FontMgrImp::GetFontByCodePage(uint16_t wCodePage,
-                                            uint32_t dwFontStyles,
-                                            const FX_WCHAR* pszFontFamily) {
+CFX_GEFont* CFX_FontMgrImp::GetFontByCodePage(uint16_t wCodePage,
+                                              uint32_t dwFontStyles,
+                                              const FX_WCHAR* pszFontFamily) {
   CFX_ByteString bsHash;
   bsHash.Format("%d, %d", wCodePage, dwFontStyles);
   bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
   uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
-  CFX_ArrayTemplate<IFX_Font*>* pFonts = nullptr;
+  CFX_ArrayTemplate<CFX_GEFont*>* pFonts = nullptr;
   if (m_Hash2Fonts.Lookup(dwHash, pFonts)) {
     if (!pFonts)
       return nullptr;
 
     if (pFonts->GetSize() != 0)
       return pFonts->GetAt(0)->Retain();
   }
 
   if (!pFonts)
-    pFonts = new CFX_ArrayTemplate<IFX_Font*>;
+    pFonts = new CFX_ArrayTemplate<CFX_GEFont*>;
 
   m_Hash2Fonts.SetAt(dwHash, pFonts);
   CFX_FontDescriptorInfos* sortedFonts = nullptr;
   if (!m_Hash2CandidateList.Lookup(dwHash, sortedFonts)) {
     sortedFonts = new CFX_FontDescriptorInfos;
     MatchFonts(*sortedFonts, wCodePage, dwFontStyles,
                CFX_WideString(pszFontFamily), 0);
     m_Hash2CandidateList.SetAt(dwHash, sortedFonts);
   }
   if (sortedFonts->GetSize() == 0)
     return nullptr;
 
   CFX_FontDescriptor* pDesc = sortedFonts->GetAt(0).pFont;
-  IFX_Font* pFont =
+  CFX_GEFont* pFont =
       pDesc->m_pFileAccess
           ? LoadFont(pDesc->m_pFileAccess, pDesc->m_nFaceIndex, nullptr)
           : LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
   if (pFont)
     pFont->SetLogicalFontStyle(dwFontStyles);
 
   pFonts->Add(pFont);
   return pFont;
 }
-IFX_Font* CFX_FontMgrImp::GetFontByCharset(uint8_t nCharset,
-                                           uint32_t dwFontStyles,
-                                           const FX_WCHAR* pszFontFamily) {
+CFX_GEFont* CFX_FontMgrImp::GetFontByCharset(uint8_t nCharset,
+                                             uint32_t dwFontStyles,
+                                             const FX_WCHAR* pszFontFamily) {
   return GetFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                            pszFontFamily);
 }
-IFX_Font* CFX_FontMgrImp::GetFontByUnicode(FX_WCHAR wUnicode,
-                                           uint32_t dwFontStyles,
-                                           const FX_WCHAR* pszFontFamily) {
-  IFX_Font* pFont = nullptr;
+CFX_GEFont* CFX_FontMgrImp::GetFontByUnicode(FX_WCHAR wUnicode,
+                                             uint32_t dwFontStyles,
+                                             const FX_WCHAR* pszFontFamily) {
+  CFX_GEFont* pFont = nullptr;
   if (m_FailedUnicodes2NULL.Lookup(wUnicode, pFont))
     return nullptr;
   const FGAS_FONTUSB* x = FGAS_GetUnicodeBitField(wUnicode);
   uint16_t wCodePage = x ? x->wCodePage : 0xFFFF;
   uint16_t wBitField = x ? x->wBitField : 0x03E7;
   CFX_ByteString bsHash;
   if (wCodePage == 0xFFFF)
     bsHash.Format("%d, %d, %d", wCodePage, wBitField, dwFontStyles);
   else
     bsHash.Format("%d, %d", wCodePage, dwFontStyles);
   bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
   uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
-  CFX_ArrayTemplate<IFX_Font*>* pFonts = nullptr;
+  CFX_ArrayTemplate<CFX_GEFont*>* pFonts = nullptr;
   if (m_Hash2Fonts.Lookup(dwHash, pFonts)) {
     if (!pFonts)
       return nullptr;
     for (int32_t i = 0; i < pFonts->GetSize(); ++i) {
       if (VerifyUnicode(pFonts->GetAt(i), wUnicode))
         return pFonts->GetAt(i)->Retain();
     }
   }
   if (!pFonts)
-    pFonts = new CFX_ArrayTemplate<IFX_Font*>;
+    pFonts = new CFX_ArrayTemplate<CFX_GEFont*>;
   m_Hash2Fonts.SetAt(dwHash, pFonts);
   CFX_FontDescriptorInfos* sortedFonts = nullptr;
   if (!m_Hash2CandidateList.Lookup(dwHash, sortedFonts)) {
     sortedFonts = new CFX_FontDescriptorInfos;
     MatchFonts(*sortedFonts, wCodePage, dwFontStyles,
                CFX_WideString(pszFontFamily), wUnicode);
     m_Hash2CandidateList.SetAt(dwHash, sortedFonts);
   }
   for (int32_t i = 0; i < sortedFonts->GetSize(); ++i) {
     CFX_FontDescriptor* pDesc = sortedFonts->GetAt(i).pFont;
@@ skipping 27 matching lines @@
   FT_Error retIndex = FXFT_Get_Char_Index(pFace, wcUnicode);
   pFileRead->Release();
   if (!pFace)
     return FALSE;
   if (FXFT_Get_Face_External_Stream(pFace))
     FXFT_Clear_Face_External_Stream(pFace);
   FXFT_Done_Face(pFace);
   return !retCharmap && retIndex;
 }
 
-FX_BOOL CFX_FontMgrImp::VerifyUnicode(IFX_Font* pFont, FX_WCHAR wcUnicode) {
+FX_BOOL CFX_FontMgrImp::VerifyUnicode(CFX_GEFont* pFont, FX_WCHAR wcUnicode) {
   if (!pFont)
     return FALSE;
 
   FXFT_Face pFace = ((CFX_Font*)pFont->GetDevFont())->GetFace();
   FXFT_CharMap charmap = FXFT_Get_Face_Charmap(pFace);
   if (FXFT_Select_Charmap(pFace, FXFT_ENCODING_UNICODE) != 0)
     return FALSE;
 
   if (FXFT_Get_Char_Index(pFace, wcUnicode) == 0) {
     FXFT_Set_Charmap(pFace, charmap);
     return FALSE;
   }
   return TRUE;
 }
 
-IFX_Font* CFX_FontMgrImp::GetFontByLanguage(uint16_t wLanguage,
-                                            uint32_t dwFontStyles,
-                                            const FX_WCHAR* pszFontFamily) {
+CFX_GEFont* CFX_FontMgrImp::GetFontByLanguage(uint16_t wLanguage,
+                                              uint32_t dwFontStyles,
+                                              const FX_WCHAR* pszFontFamily) {
   return GetFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage), dwFontStyles,
                            pszFontFamily);
 }
 
-IFX_Font* CFX_FontMgrImp::LoadFont(const uint8_t* pBuffer,
-                                   int32_t iLength,
-                                   int32_t iFaceIndex,
-                                   int32_t* pFaceCount) {
+CFX_GEFont* CFX_FontMgrImp::LoadFont(const uint8_t* pBuffer,
+                                     int32_t iLength,
+                                     int32_t iFaceIndex,
+                                     int32_t* pFaceCount) {
   void* Hash[2] = {(void*)(uintptr_t)pBuffer, (void*)(uintptr_t)iLength};
   uint32_t dwHash =
       FX_HashCode_GetA(CFX_ByteStringC((uint8_t*)Hash, sizeof(Hash)), false);
   IFX_FileAccess* pFontAccess = nullptr;
   m_Hash2FileAccess.Lookup(dwHash, pFontAccess);
   return pFontAccess ? LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE)
                      : nullptr;
 }
 
-IFX_Font* CFX_FontMgrImp::LoadFont(const FX_WCHAR* pszFileName,
-                                   int32_t iFaceIndex,
-                                   int32_t* pFaceCount) {
+CFX_GEFont* CFX_FontMgrImp::LoadFont(const FX_WCHAR* pszFileName,
+                                     int32_t iFaceIndex,
+                                     int32_t* pFaceCount) {
   CFX_ByteString bsHash;
   bsHash += CFX_WideString(pszFileName).UTF8Encode();
 
   uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
   IFX_FileAccess* pFontAccess = nullptr;
   if (!m_Hash2FileAccess.Lookup(dwHash, pFontAccess)) {
     pFontAccess = FX_CreateDefaultFileAccess(pszFileName);
     m_Hash2FileAccess.SetAt(dwHash, pFontAccess);
   }
 
   return pFontAccess ? LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE)
                      : nullptr;
 }
 
-IFX_Font* CFX_FontMgrImp::LoadFont(IFX_Stream* pFontStream,
-                                   int32_t iFaceIndex,
-                                   int32_t* pFaceCount,
-                                   FX_BOOL bSaveStream) {
+CFX_GEFont* CFX_FontMgrImp::LoadFont(IFX_Stream* pFontStream,
+                                     int32_t iFaceIndex,
+                                     int32_t* pFaceCount,
+                                     FX_BOOL bSaveStream) {
   void* Hash[1] = {(void*)(uintptr_t)pFontStream};
   uint32_t dwHash =
       FX_HashCode_GetA(CFX_ByteStringC((uint8_t*)Hash, sizeof(Hash)), false);
   IFX_FileAccess* pFontAccess = nullptr;
   m_Hash2FileAccess.Lookup(dwHash, pFontAccess);
 
   return pFontAccess ? LoadFont(pFontAccess, iFaceIndex, pFaceCount, TRUE)
                      : nullptr;
 }
 
-IFX_Font* CFX_FontMgrImp::LoadFont(IFX_FileAccess* pFontAccess,
-                                   int32_t iFaceIndex,
-                                   int32_t* pFaceCount,
-                                   FX_BOOL bWantCache) {
+CFX_GEFont* CFX_FontMgrImp::LoadFont(IFX_FileAccess* pFontAccess,
+                                     int32_t iFaceIndex,
+                                     int32_t* pFaceCount,
+                                     FX_BOOL bWantCache) {
   uint32_t dwHash = 0;
-  IFX_Font* pFont = nullptr;
+  CFX_GEFont* pFont = nullptr;
   if (bWantCache) {
     CFX_ByteString bsHash;
     bsHash.Format("%d, %d", (uintptr_t)pFontAccess, iFaceIndex);
     dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false);
     if (m_FileAccess2IFXFont.Lookup(dwHash, pFont)) {
       if (pFont) {
         if (pFaceCount)
           *pFaceCount = ((CFX_Font*)pFont->GetDevFont())->GetFace()->num_faces;
         return pFont->Retain();
       }
     }
   }
 
   CFX_Font* pInternalFont = new CFX_Font;
   IFX_FileRead* pFontStream =
       pFontAccess->CreateFileStream(FX_FILEMODE_ReadOnly);
   if (!pFontStream) {
     delete pInternalFont;
     return nullptr;
   }
   if (!pInternalFont->LoadFile(pFontStream, iFaceIndex)) {
     delete pInternalFont;
     pFontStream->Release();
     return nullptr;
   }
-  pFont = IFX_Font::LoadFont(pInternalFont, this, TRUE);
+  pFont = CFX_GEFont::LoadFont(pInternalFont, this, TRUE);
   if (!pFont) {
     delete pInternalFont;
     pFontStream->Release();
     return nullptr;
   }
   if (bWantCache)
     m_FileAccess2IFXFont.SetAt(dwHash, pFont);
 
   m_IFXFont2FileRead.SetAt(pFont, pFontStream);
   if (pFaceCount)
     *pFaceCount = ((CFX_Font*)pFont->GetDevFont())->GetFace()->num_faces;
 
   return pFont;
 }
 
-IFX_Font* CFX_FontMgrImp::LoadFont(const CFX_WideString& wsFaceName,
-                                   int32_t iFaceIndex,
-                                   int32_t* pFaceCount) {
+CFX_GEFont* CFX_FontMgrImp::LoadFont(const CFX_WideString& wsFaceName,
+                                     int32_t iFaceIndex,
+                                     int32_t* pFaceCount) {
   CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
   CFX_FontMapper* pFontMapper = pFontMgr->GetBuiltinMapper();
   if (!pFontMapper)
     return nullptr;
 
   IFX_SystemFontInfo* pSystemFontInfo = pFontMapper->GetSystemFontInfo();
   if (!pSystemFontInfo)
     return nullptr;
 
   IFX_FileRead* pFontStream = CreateFontStream(wsFaceName.UTF8Encode());
   if (!pFontStream)
     return nullptr;
 
   if (!LoadFace(pFontStream, 0)) {
     pFontStream->Release();
     return nullptr;
   }
 
   CFX_Font* pInternalFont = new CFX_Font();
   if (!pInternalFont->LoadFile(pFontStream, iFaceIndex)) {
     pFontStream->Release();
     return nullptr;
   }
 
-  IFX_Font* pFont = IFX_Font::LoadFont(pInternalFont, this, FALSE);
+  CFX_GEFont* pFont = CFX_GEFont::LoadFont(pInternalFont, this, FALSE);
   if (!pFont) {
     pFontStream->Release();
     return nullptr;
   }
 
   m_IFXFont2FileRead.SetAt(pFont, pFontStream);
   if (pFaceCount)
     *pFaceCount = ((CFX_Font*)pFont->GetDevFont())->GetFace()->num_faces;
 
   return pFont;
@@ skipping 243 matching lines @@
   FX_POSITION pos = m_Hash2CandidateList.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     delete pDescs;
   }
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
-    IFX_Font* pFont;
+    CFX_GEFont* pFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pFont);
     if (NULL != pFont) {
       pFont->Release();
     }
   }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
-    IFX_Font* pFont;
+    CFX_GEFont* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
 }
-void CFX_FontMgrImp::RemoveFont(IFX_Font* pEFont) {
+void CFX_FontMgrImp::RemoveFont(CFX_GEFont* pEFont) {
   if (NULL == pEFont) {
     return;
   }
   IFX_FileRead* pFileRead;
   if (m_IFXFont2FileRead.Lookup(pEFont, pFileRead)) {
     pFileRead->Release();
     m_IFXFont2FileRead.RemoveKey(pEFont);
   }
   FX_POSITION pos;
   pos = m_FileAccess2IFXFont.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
-    IFX_Font* pCFont;
+    CFX_GEFont* pCFont;
     m_FileAccess2IFXFont.GetNextAssoc(pos, dwHash, pCFont);
     if (pCFont == pEFont) {
       m_FileAccess2IFXFont.RemoveKey(dwHash);
       break;
     }
   }
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
-    CFX_ArrayTemplate<IFX_Font*>* pFonts;
+    CFX_ArrayTemplate<CFX_GEFont*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
     if (NULL != pFonts) {
       for (int32_t i = 0; i < pFonts->GetSize(); i++) {
         if (pFonts->GetAt(i) == pEFont) {
           pFonts->SetAt(i, NULL);
         }
       }
     } else {
       m_Hash2Fonts.RemoveKey(dwHash);
     }
@@ skipping 227 matching lines @@
   }
 }
 int32_t CFX_FontMgrImp::IsPartName(const CFX_WideString& Name1,
                                    const CFX_WideString& Name2) {
   if (Name1.Find(Name2.c_str()) != -1) {
     return 1;
   }
   return 0;
 }
 #endif