diff options
Diffstat (limited to 'xfa/fgas/font/cfgas_fontmgr.cpp')
| -rw-r--r-- | xfa/fgas/font/cfgas_fontmgr.cpp | 1282 |
1 files changed, 1282 insertions, 0 deletions
diff --git a/xfa/fgas/font/cfgas_fontmgr.cpp b/xfa/fgas/font/cfgas_fontmgr.cpp new file mode 100644 index 0000000000..460acf801b --- /dev/null +++ b/xfa/fgas/font/cfgas_fontmgr.cpp @@ -0,0 +1,1282 @@ +// Copyright 2015 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/cfgas_fontmgr.h" + +#include "core/fxcrt/fx_stream.h" +#include "core/fxge/cfx_fontmapper.h" +#include "core/fxge/cfx_fontmgr.h" +#include "core/fxge/cfx_gemodule.h" +#include "core/fxge/ifx_systemfontinfo.h" +#include "third_party/base/ptr_util.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_ + +namespace { + +int32_t GetSimilarityScore(FX_FONTDESCRIPTOR const* pFont, + uint32_t dwFontStyles) { + int32_t iValue = 0; + if ((dwFontStyles & FX_FONTSTYLE_Symbolic) == + (pFont->dwFontStyles & FX_FONTSTYLE_Symbolic)) { + iValue += 64; + } + if ((dwFontStyles & FX_FONTSTYLE_FixedPitch) == + (pFont->dwFontStyles & FX_FONTSTYLE_FixedPitch)) { + iValue += 32; + } + if ((dwFontStyles & FX_FONTSTYLE_Serif) == + (pFont->dwFontStyles & FX_FONTSTYLE_Serif)) { + iValue += 16; + } + if ((dwFontStyles & FX_FONTSTYLE_Script) == + (pFont->dwFontStyles & FX_FONTSTYLE_Script)) { + iValue += 8; + } + return iValue; +} + +FX_FONTDESCRIPTOR const* MatchDefaultFont(FX_LPFONTMATCHPARAMS pParams, + const CFX_FontDescriptors& fonts) { + FX_FONTDESCRIPTOR const* pBestFont = nullptr; + int32_t iBestSimilar = 0; + bool bMatchStyle = (pParams->dwMatchFlags & FX_FONTMATCHPARA_MatchStyle) > 0; + for (int32_t i = 0; i < fonts.GetSize(); ++i) { + FX_FONTDESCRIPTOR const* pFont = fonts.GetPtrAt(i); + if ((pFont->dwFontStyles & FX_FONTSTYLE_BoldItalic) == + FX_FONTSTYLE_BoldItalic) { + continue; + } + if (pParams->pwsFamily) { + if (FXSYS_wcsicmp(pParams->pwsFamily, pFont->wsFontFace)) + continue; + if (pFont->uCharSet == FX_CHARSET_Symbol) + return pFont; + } + if (pFont->uCharSet == FX_CHARSET_Symbol) + continue; + if (pParams->wCodePage != 0xFFFF) { + if (FX_GetCodePageFromCharset(pFont->uCharSet) != pParams->wCodePage) + continue; + } else { + if (pParams->dwUSB < 128) { + uint32_t dwByte = pParams->dwUSB / 32; + uint32_t dwUSB = 1 << (pParams->dwUSB % 32); + if ((pFont->FontSignature.fsUsb[dwByte] & dwUSB) == 0) + continue; + } + } + if (bMatchStyle) { + if ((pFont->dwFontStyles & 0x0F) == (pParams->dwFontStyles & 0x0F)) + return pFont; + continue; + } + if (pParams->pwsFamily) { + if (FXSYS_wcsicmp(pParams->pwsFamily, pFont->wsFontFace) == 0) + return pFont; + } + int32_t iSimilarValue = GetSimilarityScore(pFont, pParams->dwFontStyles); + if (iBestSimilar < iSimilarValue) { + iBestSimilar = iSimilarValue; + pBestFont = pFont; + } + } + return iBestSimilar < 1 ? nullptr : pBestFont; +} + +} // namespace + +std::unique_ptr<CFGAS_FontMgr> CFGAS_FontMgr::Create( + FX_LPEnumAllFonts pEnumerator) { + return pdfium::MakeUnique<CFGAS_FontMgr>(pEnumerator); +} + +CFGAS_FontMgr::CFGAS_FontMgr(FX_LPEnumAllFonts pEnumerator) + : m_pEnumerator(pEnumerator), + m_FontFaces(100), + m_CPFonts(8), + m_FamilyFonts(16), + m_UnicodeFonts(16), + m_BufferFonts(4), + m_StreamFonts(4), + m_DeriveFonts(4) { + if (m_pEnumerator) + m_pEnumerator(m_FontFaces, nullptr, 0xFEFF); +} + +CFGAS_FontMgr::~CFGAS_FontMgr() { + m_FontFaces.RemoveAll(false); + m_CPFonts.RemoveAll(); + m_FamilyFonts.RemoveAll(); + m_UnicodeFonts.RemoveAll(); + m_BufferFonts.RemoveAll(); + m_StreamFonts.RemoveAll(); + m_DeriveFonts.RemoveAll(); + for (int32_t i = m_Fonts.GetUpperBound(); i >= 0; i--) + m_Fonts[i]->Release(); +} + +CFGAS_GEFont* CFGAS_FontMgr::GetDefFontByCodePage( + uint16_t wCodePage, + uint32_t dwFontStyles, + const FX_WCHAR* pszFontFamily) { + uint32_t dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles); + CFGAS_GEFont* pFont = nullptr; + if (m_CPFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) + return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr; + FX_FONTDESCRIPTOR const* pFD = + FindFont(pszFontFamily, dwFontStyles, true, wCodePage); + if (!pFD) + pFD = FindFont(nullptr, dwFontStyles, true, wCodePage); + if (!pFD) + pFD = FindFont(nullptr, dwFontStyles, false, wCodePage); + if (!pFD) + return nullptr; + + pFont = + CFGAS_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 nullptr; +} + +CFGAS_GEFont* CFGAS_FontMgr::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); + CFGAS_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 = CFGAS_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; +} + +CFGAS_GEFont* CFGAS_FontMgr::LoadFont(const FX_WCHAR* pszFontFamily, + uint32_t dwFontStyles, + uint16_t wCodePage) { + uint32_t dwHash = + FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage); + CFGAS_GEFont* pFont = nullptr; + if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) + return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr; + FX_FONTDESCRIPTOR const* pFD = + FindFont(pszFontFamily, dwFontStyles, true, wCodePage); + if (!pFD) + pFD = FindFont(pszFontFamily, dwFontStyles, false, wCodePage); + if (!pFD) + return nullptr; + + if (wCodePage == 0xFFFF) + wCodePage = FX_GetCodePageFromCharset(pFD->uCharSet); + pFont = + CFGAS_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 nullptr; +} + +CFGAS_GEFont* CFGAS_FontMgr::LoadFont(const uint8_t* pBuffer, int32_t iLength) { + ASSERT(pBuffer && iLength > 0); + CFGAS_GEFont* pFont = nullptr; + if (m_BufferFonts.Lookup((void*)pBuffer, (void*&)pFont)) { + if (pFont) + return pFont->Retain(); + } + pFont = CFGAS_GEFont::LoadFont(pBuffer, iLength, this); + if (pFont) { + m_Fonts.Add(pFont); + m_BufferFonts.SetAt((void*)pBuffer, pFont); + return pFont->Retain(); + } + return nullptr; +} + +CFGAS_GEFont* CFGAS_FontMgr::LoadFont(IFX_Stream* pFontStream, + const FX_WCHAR* pszFontAlias, + uint32_t dwFontStyles, + uint16_t wCodePage, + bool bSaveStream) { + ASSERT(pFontStream && pFontStream->GetLength() > 0); + CFGAS_GEFont* pFont = nullptr; + 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 = CFGAS_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 nullptr; +} + +CFGAS_GEFont* CFGAS_FontMgr::LoadFont(CFGAS_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); + CFGAS_GEFont* pFont = nullptr; + 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 nullptr; +} + +void CFGAS_FontMgr::ClearFontCache() { + for (int32_t i = 0; i < m_Fonts.GetSize(); i++) + m_Fonts[i]->Reset(); +} + +void CFGAS_FontMgr::RemoveFont(CFX_MapPtrToPtr& fontMap, CFGAS_GEFont* pFont) { + FX_POSITION pos = fontMap.GetStartPosition(); + void* pKey; + void* pFind; + while (pos) { + pFind = nullptr; + fontMap.GetNextAssoc(pos, pKey, pFind); + if (pFind != (void*)pFont) + continue; + fontMap.RemoveKey(pKey); + break; + } +} + +void CFGAS_FontMgr::RemoveFont(CFGAS_GEFont* pFont) { + RemoveFont(m_CPFonts, pFont); + RemoveFont(m_FamilyFonts, pFont); + RemoveFont(m_UnicodeFonts, pFont); + RemoveFont(m_BufferFonts, pFont); + RemoveFont(m_StreamFonts, pFont); + RemoveFont(m_DeriveFonts, pFont); + int32_t iFind = m_Fonts.Find(pFont); + if (iFind > -1) + m_Fonts.RemoveAt(iFind, 1); +} + +FX_FONTDESCRIPTOR const* CFGAS_FontMgr::FindFont(const FX_WCHAR* pszFontFamily, + uint32_t dwFontStyles, + uint32_t dwMatchFlags, + uint16_t wCodePage, + uint32_t dwUSB, + FX_WCHAR wUnicode) { + FX_FONTMATCHPARAMS params; + FXSYS_memset(¶ms, 0, sizeof(params)); + params.dwUSB = dwUSB; + params.wUnicode = wUnicode; + params.wCodePage = wCodePage; + params.pwsFamily = pszFontFamily; + params.dwFontStyles = dwFontStyles; + params.dwMatchFlags = dwMatchFlags; + FX_FONTDESCRIPTOR const* pDesc = MatchDefaultFont(¶ms, m_FontFaces); + if (pDesc) + return pDesc; + if (pszFontFamily && m_pEnumerator) { + CFX_FontDescriptors namedFonts(100); + m_pEnumerator(namedFonts, pszFontFamily, wUnicode); + params.pwsFamily = nullptr; + pDesc = MatchDefaultFont(¶ms, namedFonts); + if (!pDesc) + return nullptr; + for (int32_t i = m_FontFaces.GetSize() - 1; i >= 0; i--) { + FX_FONTDESCRIPTOR const* pMatch = m_FontFaces.GetPtrAt(i); + if (*pMatch == *pDesc) + return pMatch; + } + int index = m_FontFaces.Add(*pDesc); + return m_FontFaces.GetPtrAt(index); + } + return nullptr; +} + +uint32_t FX_GetGdiFontStyles(const LOGFONTW& lf) { + uint32_t dwStyles = 0; + if ((lf.lfPitchAndFamily & 0x03) == FIXED_PITCH) + dwStyles |= FX_FONTSTYLE_FixedPitch; + uint8_t nFamilies = lf.lfPitchAndFamily & 0xF0; + if (nFamilies == FF_ROMAN) + dwStyles |= FX_FONTSTYLE_Serif; + if (nFamilies == FF_SCRIPT) + dwStyles |= FX_FONTSTYLE_Script; + if (lf.lfCharSet == SYMBOL_CHARSET) + dwStyles |= FX_FONTSTYLE_Symbolic; + return dwStyles; +} + +static int32_t CALLBACK FX_GdiFontEnumProc(ENUMLOGFONTEX* lpelfe, + NEWTEXTMETRICEX* lpntme, + DWORD dwFontType, + LPARAM lParam) { + if (dwFontType != TRUETYPE_FONTTYPE) + return 1; + const LOGFONTW& lf = ((LPENUMLOGFONTEXW)lpelfe)->elfLogFont; + if (lf.lfFaceName[0] == L'@') + return 1; + FX_FONTDESCRIPTOR* pFont = FX_Alloc(FX_FONTDESCRIPTOR, 1); + FXSYS_memset(pFont, 0, sizeof(FX_FONTDESCRIPTOR)); + pFont->uCharSet = lf.lfCharSet; + pFont->dwFontStyles = FX_GetGdiFontStyles(lf); + FXSYS_wcsncpy(pFont->wsFontFace, (const FX_WCHAR*)lf.lfFaceName, 31); + pFont->wsFontFace[31] = 0; + FXSYS_memcpy(&pFont->FontSignature, &lpntme->ntmFontSig, + sizeof(lpntme->ntmFontSig)); + ((CFX_FontDescriptors*)lParam)->Add(*pFont); + FX_Free(pFont); + return 1; +} + +static void FX_EnumGdiFonts(CFX_FontDescriptors& fonts, + const FX_WCHAR* pwsFaceName, + FX_WCHAR wUnicode) { + HDC hDC = ::GetDC(nullptr); + LOGFONTW lfFind; + FXSYS_memset(&lfFind, 0, sizeof(lfFind)); + lfFind.lfCharSet = DEFAULT_CHARSET; + if (pwsFaceName) { + FXSYS_wcsncpy(lfFind.lfFaceName, pwsFaceName, 31); + lfFind.lfFaceName[31] = 0; + } + EnumFontFamiliesExW(hDC, (LPLOGFONTW)&lfFind, + (FONTENUMPROCW)FX_GdiFontEnumProc, (LPARAM)&fonts, 0); + ::ReleaseDC(nullptr, hDC); +} + +FX_LPEnumAllFonts FX_GetDefFontEnumerator() { + return FX_EnumGdiFonts; +} + +#else // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ + +namespace { + +const FX_CHAR* g_FontFolders[] = { +#if _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_ + "/usr/share/fonts", "/usr/share/X11/fonts/Type1", + "/usr/share/X11/fonts/TTF", "/usr/local/share/fonts", +#elif _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ + "~/Library/Fonts", "/Library/Fonts", "/System/Library/Fonts", +#elif _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_ + "/system/fonts", +#endif +}; + +struct FX_BitCodePage { + uint16_t wBit; + uint16_t wCodePage; +}; + +const FX_BitCodePage g_Bit2CodePage[] = { + {0, 1252}, {1, 1250}, {2, 1251}, {3, 1253}, {4, 1254}, {5, 1255}, + {6, 1256}, {7, 1257}, {8, 1258}, {9, 0}, {10, 0}, {11, 0}, + {12, 0}, {13, 0}, {14, 0}, {15, 0}, {16, 874}, {17, 932}, + {18, 936}, {19, 949}, {20, 950}, {21, 1361}, {22, 0}, {23, 0}, + {24, 0}, {25, 0}, {26, 0}, {27, 0}, {28, 0}, {29, 0}, + {30, 0}, {31, 0}, {32, 0}, {33, 0}, {34, 0}, {35, 0}, + {36, 0}, {37, 0}, {38, 0}, {39, 0}, {40, 0}, {41, 0}, + {42, 0}, {43, 0}, {44, 0}, {45, 0}, {46, 0}, {47, 0}, + {48, 869}, {49, 866}, {50, 865}, {51, 864}, {52, 863}, {53, 862}, + {54, 861}, {55, 860}, {56, 857}, {57, 855}, {58, 852}, {59, 775}, + {60, 737}, {61, 708}, {62, 850}, {63, 437}, +}; + +uint16_t FX_GetCodePageBit(uint16_t wCodePage) { + for (size_t i = 0; i < FX_ArraySize(g_Bit2CodePage); ++i) { + if (g_Bit2CodePage[i].wCodePage == wCodePage) + return g_Bit2CodePage[i].wBit; + } + return (uint16_t)-1; +} + +uint16_t FX_GetUnicodeBit(FX_WCHAR wcUnicode) { + const FGAS_FONTUSB* x = FGAS_GetUnicodeBitField(wcUnicode); + return x ? x->wBitField : 999; +} + +inline uint8_t GetUInt8(const uint8_t* p) { + return (uint8_t)(p[0]); +} + +inline uint16_t GetUInt16(const uint8_t* p) { + return (uint16_t)(p[0] << 8 | p[1]); +} + +struct FX_BIT2CHARSET { + uint16_t wBit; + uint16_t wCharset; +}; + +const FX_BIT2CHARSET g_FX_Bit2Charset1[16] = { + {1 << 0, FX_CHARSET_ANSI}, + {1 << 1, FX_CHARSET_MSWin_EasterEuropean}, + {1 << 2, FX_CHARSET_MSWin_Cyrillic}, + {1 << 3, FX_CHARSET_MSWin_Greek}, + {1 << 4, FX_CHARSET_MSWin_Turkish}, + {1 << 5, FX_CHARSET_MSWin_Hebrew}, + {1 << 6, FX_CHARSET_MSWin_Arabic}, + {1 << 7, FX_CHARSET_MSWin_Baltic}, + {1 << 8, FX_CHARSET_MSWin_Vietnamese}, + {1 << 9, FX_CHARSET_Default}, + {1 << 10, FX_CHARSET_Default}, + {1 << 11, FX_CHARSET_Default}, + {1 << 12, FX_CHARSET_Default}, + {1 << 13, FX_CHARSET_Default}, + {1 << 14, FX_CHARSET_Default}, + {1 << 15, FX_CHARSET_Default}, +}; + +const FX_BIT2CHARSET g_FX_Bit2Charset2[16] = { + {1 << 0, FX_CHARSET_Thai}, + {1 << 1, FX_CHARSET_ShiftJIS}, + {1 << 2, FX_CHARSET_ChineseSimplified}, + {1 << 3, FX_CHARSET_Korean}, + {1 << 4, FX_CHARSET_ChineseTriditional}, + {1 << 5, FX_CHARSET_Johab}, + {1 << 6, FX_CHARSET_Default}, + {1 << 7, FX_CHARSET_Default}, + {1 << 8, FX_CHARSET_Default}, + {1 << 9, FX_CHARSET_Default}, + {1 << 10, FX_CHARSET_Default}, + {1 << 11, FX_CHARSET_Default}, + {1 << 12, FX_CHARSET_Default}, + {1 << 13, FX_CHARSET_Default}, + {1 << 14, FX_CHARSET_OEM}, + {1 << 15, FX_CHARSET_Symbol}, +}; + +const FX_BIT2CHARSET g_FX_Bit2Charset3[16] = { + {1 << 0, FX_CHARSET_Default}, {1 << 1, FX_CHARSET_Default}, + {1 << 2, FX_CHARSET_Default}, {1 << 3, FX_CHARSET_Default}, + {1 << 4, FX_CHARSET_Default}, {1 << 5, FX_CHARSET_Default}, + {1 << 6, FX_CHARSET_Default}, {1 << 7, FX_CHARSET_Default}, + {1 << 8, FX_CHARSET_Default}, {1 << 9, FX_CHARSET_Default}, + {1 << 10, FX_CHARSET_Default}, {1 << 11, FX_CHARSET_Default}, + {1 << 12, FX_CHARSET_Default}, {1 << 13, FX_CHARSET_Default}, + {1 << 14, FX_CHARSET_Default}, {1 << 15, FX_CHARSET_Default}, +}; + +const FX_BIT2CHARSET g_FX_Bit2Charset4[16] = { + {1 << 0, FX_CHARSET_Default}, {1 << 1, FX_CHARSET_Default}, + {1 << 2, FX_CHARSET_Default}, {1 << 3, FX_CHARSET_Default}, + {1 << 4, FX_CHARSET_Default}, {1 << 5, FX_CHARSET_Default}, + {1 << 6, FX_CHARSET_Default}, {1 << 7, FX_CHARSET_Default}, + {1 << 8, FX_CHARSET_Default}, {1 << 9, FX_CHARSET_Default}, + {1 << 10, FX_CHARSET_Default}, {1 << 11, FX_CHARSET_Default}, + {1 << 12, FX_CHARSET_Default}, {1 << 13, FX_CHARSET_Default}, + {1 << 14, FX_CHARSET_Default}, {1 << 15, FX_CHARSET_US}, +}; + +} // namespace + +CFX_FontDescriptor::CFX_FontDescriptor() + : m_nFaceIndex(0), m_dwFontStyles(0), m_dwUsb(), m_dwCsb() {} + +CFX_FontDescriptor::~CFX_FontDescriptor() {} + +CFX_FontSourceEnum_File::CFX_FontSourceEnum_File() { + for (size_t i = 0; i < FX_ArraySize(g_FontFolders); ++i) + m_FolderPaths.Add(g_FontFolders[i]); +} + +CFX_FontSourceEnum_File::~CFX_FontSourceEnum_File() {} + +CFX_ByteString CFX_FontSourceEnum_File::GetNextFile() { + FX_FileHandle* pCurHandle = + m_FolderQueue.GetSize() != 0 + ? m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->pFileHandle + : nullptr; + if (!pCurHandle) { + if (m_FolderPaths.GetSize() < 1) + return ""; + pCurHandle = + FX_OpenFolder(m_FolderPaths[m_FolderPaths.GetSize() - 1].c_str()); + FX_HandleParentPath hpp; + hpp.pFileHandle = pCurHandle; + hpp.bsParentPath = m_FolderPaths[m_FolderPaths.GetSize() - 1]; + m_FolderQueue.Add(hpp); + } + CFX_ByteString bsName; + bool bFolder; + CFX_ByteString bsFolderSpearator = + CFX_ByteString::FromUnicode(CFX_WideString(FX_GetFolderSeparator())); + while (true) { + if (!FX_GetNextFile(pCurHandle, &bsName, &bFolder)) { + FX_CloseFolder(pCurHandle); + m_FolderQueue.RemoveAt(m_FolderQueue.GetSize() - 1); + if (m_FolderQueue.GetSize() == 0) { + m_FolderPaths.RemoveAt(m_FolderPaths.GetSize() - 1); + return m_FolderPaths.GetSize() != 0 ? GetNextFile() : ""; + } + pCurHandle = + m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->pFileHandle; + continue; + } + if (bsName == "." || bsName == "..") + continue; + if (bFolder) { + FX_HandleParentPath hpp; + hpp.bsParentPath = + m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->bsParentPath + + bsFolderSpearator + bsName; + hpp.pFileHandle = FX_OpenFolder(hpp.bsParentPath.c_str()); + if (!hpp.pFileHandle) + continue; + m_FolderQueue.Add(hpp); + pCurHandle = hpp.pFileHandle; + continue; + } + bsName = + m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->bsParentPath + + bsFolderSpearator + bsName; + break; + } + return bsName; +} + +FX_POSITION CFX_FontSourceEnum_File::GetStartPosition() { + m_wsNext = GetNextFile().UTF8Decode(); + if (m_wsNext.GetLength() == 0) + return (FX_POSITION)0; + return (FX_POSITION)-1; +} + +IFX_FileAccess* CFX_FontSourceEnum_File::GetNext(FX_POSITION& pos) { + IFX_FileAccess* pAccess = FX_CreateDefaultFileAccess(m_wsNext.AsStringC()); + m_wsNext = GetNextFile().UTF8Decode(); + pos = m_wsNext.GetLength() != 0 ? pAccess : nullptr; + return pAccess; +} + +std::unique_ptr<CFGAS_FontMgr> CFGAS_FontMgr::Create( + CFX_FontSourceEnum_File* pFontEnum) { + if (!pFontEnum) + return nullptr; + + auto pFontMgr = pdfium::MakeUnique<CFGAS_FontMgr>(pFontEnum); + if (!pFontMgr->EnumFonts()) + return nullptr; + return pFontMgr; +} + +CFGAS_FontMgr::CFGAS_FontMgr(CFX_FontSourceEnum_File* pFontEnum) + : m_pFontSource(pFontEnum) {} + +CFGAS_FontMgr::~CFGAS_FontMgr() { + for (int32_t i = 0; i < m_InstalledFonts.GetSize(); i++) + delete m_InstalledFonts[i]; + 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<CFGAS_GEFont*>* pFonts; + m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts); + for (int32_t i = 0; i < pFonts->GetSize(); i++) + delete pFonts->GetAt(i); + delete pFonts; + } + m_Hash2Fonts.RemoveAll(); + pos = m_IFXFont2FileRead.GetStartPosition(); + while (pos) { + CFGAS_GEFont* pFont; + IFX_SeekableReadStream* pFileRead; + m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead); + pFileRead->Release(); + } +} + +bool CFGAS_FontMgr::EnumFontsFromFontMapper() { + CFX_FontMapper* pFontMapper = + CFX_GEModule::Get()->GetFontMgr()->GetBuiltinMapper(); + if (!pFontMapper) + return false; + + IFX_SystemFontInfo* pSystemFontInfo = pFontMapper->GetSystemFontInfo(); + if (!pSystemFontInfo) + return false; + + pSystemFontInfo->EnumFontList(pFontMapper); + for (int32_t i = 0; i < pFontMapper->GetFaceSize(); ++i) { + IFX_SeekableReadStream* pFontStream = + CreateFontStream(pFontMapper, pSystemFontInfo, i); + if (!pFontStream) + continue; + + CFX_WideString wsFaceName = + CFX_WideString::FromLocal(pFontMapper->GetFaceName(i).c_str()); + RegisterFaces(pFontStream, &wsFaceName); + pFontStream->Release(); + } + if (m_InstalledFonts.GetSize() == 0) + return false; + + return true; +} + +bool CFGAS_FontMgr::EnumFontsFromFiles() { + CFX_GEModule::Get()->GetFontMgr()->InitFTLibrary(); + FX_POSITION pos = m_pFontSource->GetStartPosition(); + IFX_FileAccess* pFontSource = nullptr; + IFX_SeekableReadStream* pFontStream = nullptr; + while (pos) { + pFontSource = m_pFontSource->GetNext(pos); + pFontStream = pFontSource->CreateFileStream(FX_FILEMODE_ReadOnly); + if (!pFontStream) { + pFontSource->Release(); + continue; + } + RegisterFaces(pFontStream, nullptr); + pFontStream->Release(); + pFontSource->Release(); + } + if (m_InstalledFonts.GetSize() == 0) + return false; + return true; +} + +bool CFGAS_FontMgr::EnumFonts() { + if (EnumFontsFromFontMapper()) + return true; + return EnumFontsFromFiles(); +} + +CFGAS_GEFont* CFGAS_FontMgr::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<CFGAS_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<CFGAS_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; + CFGAS_GEFont* pFont = + LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr); + if (pFont) + pFont->SetLogicalFontStyle(dwFontStyles); + + pFonts->Add(pFont); + return pFont; +} + +CFGAS_GEFont* CFGAS_FontMgr::GetFontByUnicode(FX_WCHAR wUnicode, + uint32_t dwFontStyles, + const FX_WCHAR* pszFontFamily) { + CFGAS_GEFont* pFont = nullptr; + if (m_FailedUnicodes2Nullptr.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<CFGAS_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<CFGAS_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; + if (!VerifyUnicode(pDesc, wUnicode)) + continue; + pFont = LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr); + if (!pFont) + continue; + pFont->SetLogicalFontStyle(dwFontStyles); + pFonts->Add(pFont); + return pFont; + } + if (!pszFontFamily) + m_FailedUnicodes2Nullptr.SetAt(wUnicode, nullptr); + return nullptr; +} + +bool CFGAS_FontMgr::VerifyUnicode(CFX_FontDescriptor* pDesc, + FX_WCHAR wcUnicode) { + IFX_SeekableReadStream* pFileRead = + CreateFontStream(pDesc->m_wsFaceName.UTF8Encode()); + if (!pFileRead) + return false; + FXFT_Face pFace = LoadFace(pFileRead, pDesc->m_nFaceIndex); + FT_Error retCharmap = FXFT_Select_Charmap(pFace, FXFT_ENCODING_UNICODE); + 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; +} + +bool CFGAS_FontMgr::VerifyUnicode(CFGAS_GEFont* pFont, FX_WCHAR wcUnicode) { + if (!pFont) + return false; + + FXFT_Face pFace = 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; +} + +CFGAS_GEFont* CFGAS_FontMgr::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_SeekableReadStream* pFontStream = + CreateFontStream(wsFaceName.UTF8Encode()); + if (!pFontStream) + return nullptr; + + std::unique_ptr<CFX_Font> pInternalFont(new CFX_Font()); + if (!pInternalFont->LoadFile(pFontStream, iFaceIndex)) { + pFontStream->Release(); + return nullptr; + } + + CFGAS_GEFont* pFont = CFGAS_GEFont::LoadFont(std::move(pInternalFont), this); + if (!pFont) { + pFontStream->Release(); + return nullptr; + } + + m_IFXFont2FileRead.SetAt(pFont, pFontStream); + if (pFaceCount) + *pFaceCount = pFont->GetDevFont()->GetFace()->num_faces; + + return pFont; +} + +extern "C" { + +unsigned long _ftStreamRead(FXFT_Stream stream, + unsigned long offset, + unsigned char* buffer, + unsigned long count) { + if (count == 0) + return 0; + + IFX_SeekableReadStream* pFile = + (IFX_SeekableReadStream*)stream->descriptor.pointer; + int res = pFile->ReadBlock(buffer, offset, count); + if (res) + return count; + return 0; +} + +void _ftStreamClose(FXFT_Stream stream) {} + +}; // extern "C" + +FXFT_Face CFGAS_FontMgr::LoadFace(IFX_SeekableReadStream* pFontStream, + int32_t iFaceIndex) { + if (!pFontStream) + return nullptr; + + CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr(); + pFontMgr->InitFTLibrary(); + FXFT_Library library = pFontMgr->GetFTLibrary(); + if (!library) + return nullptr; + + FXFT_Stream ftStream = FX_Alloc(FXFT_StreamRec, 1); + FXSYS_memset(ftStream, 0, sizeof(FXFT_StreamRec)); + ftStream->base = nullptr; + ftStream->descriptor.pointer = pFontStream; + ftStream->pos = 0; + ftStream->size = (unsigned long)pFontStream->GetSize(); + ftStream->read = _ftStreamRead; + ftStream->close = _ftStreamClose; + + FXFT_Open_Args ftArgs; + FXSYS_memset(&ftArgs, 0, sizeof(FXFT_Open_Args)); + ftArgs.flags |= FT_OPEN_STREAM; + ftArgs.stream = ftStream; + + FXFT_Face pFace = nullptr; + if (FXFT_Open_Face(library, &ftArgs, iFaceIndex, &pFace)) { + FX_Free(ftStream); + return nullptr; + } + + FXFT_Set_Pixel_Sizes(pFace, 0, 64); + return pFace; +} + +IFX_SeekableReadStream* CFGAS_FontMgr::CreateFontStream( + CFX_FontMapper* pFontMapper, + IFX_SystemFontInfo* pSystemFontInfo, + uint32_t index) { + int iExact = 0; + void* hFont = + pSystemFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0, + pFontMapper->GetFaceName(index).c_str(), iExact); + if (!hFont) + return nullptr; + + uint32_t dwFileSize = pSystemFontInfo->GetFontData(hFont, 0, nullptr, 0); + if (dwFileSize == 0) + return nullptr; + + uint8_t* pBuffer = FX_Alloc(uint8_t, dwFileSize + 1); + dwFileSize = pSystemFontInfo->GetFontData(hFont, 0, pBuffer, dwFileSize); + + return FX_CreateMemoryStream(pBuffer, dwFileSize, true); +} + +IFX_SeekableReadStream* CFGAS_FontMgr::CreateFontStream( + const CFX_ByteString& bsFaceName) { + 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; + + pSystemFontInfo->EnumFontList(pFontMapper); + for (int32_t i = 0; i < pFontMapper->GetFaceSize(); ++i) { + if (pFontMapper->GetFaceName(i) == bsFaceName) + return CreateFontStream(pFontMapper, pSystemFontInfo, i); + } + return nullptr; +} + +int32_t CFGAS_FontMgr::MatchFonts(CFX_FontDescriptorInfos& MatchedFonts, + uint16_t wCodePage, + uint32_t dwFontStyles, + const CFX_WideString& FontName, + FX_WCHAR wcUnicode) { + MatchedFonts.RemoveAll(); + CFX_WideString wsNormalizedFontName = FontName; + + CFX_FontDescriptor* pFont = nullptr; + int32_t nCount = m_InstalledFonts.GetSize(); + for (int32_t i = 0; i < nCount; i++) { + pFont = m_InstalledFonts[i]; + int32_t nPenalty = CalcPenalty(pFont, wCodePage, dwFontStyles, + wsNormalizedFontName, wcUnicode); + if (nPenalty >= 0xffff) + continue; + + FX_FontDescriptorInfo FontInfo; + FontInfo.pFont = pFont; + FontInfo.nPenalty = nPenalty; + MatchedFonts.Add(FontInfo); + if (MatchedFonts.GetSize() == 0xffff) + break; + } + if (MatchedFonts.GetSize() == 0) + return 0; + + CFX_SSortTemplate<FX_FontDescriptorInfo> ssort; + ssort.ShellSort(MatchedFonts.GetData(), MatchedFonts.GetSize()); + return MatchedFonts.GetSize(); +} + +int32_t CFGAS_FontMgr::CalcPenalty(CFX_FontDescriptor* pInstalled, + uint16_t wCodePage, + uint32_t dwFontStyles, + const CFX_WideString& FontName, + FX_WCHAR wcUnicode) { + int32_t nPenalty = 30000; + if (0 != FontName.GetLength()) { + if (FontName != pInstalled->m_wsFaceName) { + int32_t i; + for (i = 0; i < pInstalled->m_wsFamilyNames.GetSize(); i++) { + if (pInstalled->m_wsFamilyNames[i] == FontName) + break; + } + if (i == pInstalled->m_wsFamilyNames.GetSize()) + nPenalty += 0xFFFF; + else + nPenalty -= 28000; + } else { + nPenalty -= 30000; + } + if (30000 == nPenalty && + 0 == IsPartName(pInstalled->m_wsFaceName, FontName)) { + int32_t i; + for (i = 0; i < pInstalled->m_wsFamilyNames.GetSize(); i++) { + if (0 != IsPartName(pInstalled->m_wsFamilyNames[i], FontName)) + break; + } + if (i == pInstalled->m_wsFamilyNames.GetSize()) + nPenalty += 0xFFFF; + else + nPenalty -= 26000; + } else { + nPenalty -= 27000; + } + } + uint32_t dwStyleMask = pInstalled->m_dwFontStyles ^ dwFontStyles; + if (dwStyleMask & FX_FONTSTYLE_Bold) + nPenalty += 4500; + if (dwStyleMask & FX_FONTSTYLE_FixedPitch) + nPenalty += 10000; + if (dwStyleMask & FX_FONTSTYLE_Italic) + nPenalty += 10000; + if (dwStyleMask & FX_FONTSTYLE_Serif) + nPenalty += 500; + if (dwStyleMask & FX_FONTSTYLE_Symbolic) + nPenalty += 0xFFFF; + if (nPenalty >= 0xFFFF) + return 0xFFFF; + uint16_t wBit = + ((0 == wCodePage || 0xFFFF == wCodePage) ? (uint16_t)-1 + : FX_GetCodePageBit(wCodePage)); + if (wBit != (uint16_t)-1) { + ASSERT(wBit < 64); + if (0 == (pInstalled->m_dwCsb[wBit / 32] & (1 << (wBit % 32)))) + nPenalty += 0xFFFF; + else + nPenalty -= 60000; + } + wBit = + ((0 == wcUnicode || 0xFFFE == wcUnicode) ? (uint16_t)999 + : FX_GetUnicodeBit(wcUnicode)); + if (wBit != (uint16_t)999) { + ASSERT(wBit < 128); + if (0 == (pInstalled->m_dwUsb[wBit / 32] & (1 << (wBit % 32)))) + nPenalty += 0xFFFF; + else + nPenalty -= 60000; + } + return nPenalty; +} + +void CFGAS_FontMgr::ClearFontCache() { + FX_POSITION pos = m_Hash2CandidateList.GetStartPosition(); + while (pos) { + uint32_t dwHash; + CFX_FontDescriptorInfos* pDescs; + m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs); + delete pDescs; + } + pos = m_IFXFont2FileRead.GetStartPosition(); + while (pos) { + CFGAS_GEFont* pFont; + IFX_SeekableReadStream* pFileRead; + m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead); + pFileRead->Release(); + } +} + +void CFGAS_FontMgr::RemoveFont(CFGAS_GEFont* pEFont) { + if (!pEFont) + return; + + IFX_SeekableReadStream* pFileRead; + if (m_IFXFont2FileRead.Lookup(pEFont, pFileRead)) { + pFileRead->Release(); + m_IFXFont2FileRead.RemoveKey(pEFont); + } + FX_POSITION pos; + pos = m_Hash2Fonts.GetStartPosition(); + while (pos) { + uint32_t dwHash; + CFX_ArrayTemplate<CFGAS_GEFont*>* pFonts; + m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts); + if (pFonts) { + for (int32_t i = 0; i < pFonts->GetSize(); i++) { + if (pFonts->GetAt(i) == pEFont) + pFonts->SetAt(i, nullptr); + } + } else { + m_Hash2Fonts.RemoveKey(dwHash); + } + } +} + +void CFGAS_FontMgr::RegisterFace(FXFT_Face pFace, + const CFX_WideString* pFaceName) { + if ((pFace->face_flags & FT_FACE_FLAG_SCALABLE) == 0) + return; + + std::unique_ptr<CFX_FontDescriptor> pFont(new CFX_FontDescriptor); + pFont->m_dwFontStyles |= FXFT_Is_Face_Bold(pFace) ? FX_FONTSTYLE_Bold : 0; + pFont->m_dwFontStyles |= FXFT_Is_Face_Italic(pFace) ? FX_FONTSTYLE_Italic : 0; + pFont->m_dwFontStyles |= GetFlags(pFace); + + std::vector<uint16_t> charsets = GetCharsets(pFace); + GetUSBCSB(pFace, pFont->m_dwUsb, pFont->m_dwCsb); + + FT_ULong dwTag; + FT_ENC_TAG(dwTag, 'n', 'a', 'm', 'e'); + + std::vector<uint8_t> table; + unsigned long nLength = 0; + unsigned int error = FXFT_Load_Sfnt_Table(pFace, dwTag, 0, nullptr, &nLength); + if (error == 0 && nLength != 0) { + table.resize(nLength); + if (FXFT_Load_Sfnt_Table(pFace, dwTag, 0, table.data(), nullptr)) + table.clear(); + } + GetNames(table.empty() ? nullptr : table.data(), pFont->m_wsFamilyNames); + + pFont->m_wsFamilyNames.Add(CFX_ByteString(pFace->family_name).UTF8Decode()); + pFont->m_wsFaceName = + pFaceName ? *pFaceName + : CFX_WideString::FromLocal(FXFT_Get_Postscript_Name(pFace)); + pFont->m_nFaceIndex = pFace->face_index; + + m_InstalledFonts.Add(pFont.release()); +} + +void CFGAS_FontMgr::RegisterFaces(IFX_SeekableReadStream* pFontStream, + const CFX_WideString* pFaceName) { + int32_t index = 0; + int32_t num_faces = 0; + do { + FXFT_Face pFace = LoadFace(pFontStream, index++); + if (!pFace) + continue; + // All faces keep number of faces. It can be retrieved from any one face. + if (num_faces == 0) + num_faces = pFace->num_faces; + RegisterFace(pFace, pFaceName); + if (FXFT_Get_Face_External_Stream(pFace)) + FXFT_Clear_Face_External_Stream(pFace); + FXFT_Done_Face(pFace); + } while (index < num_faces); +} + +uint32_t CFGAS_FontMgr::GetFlags(FXFT_Face pFace) { + uint32_t flag = 0; + if (FT_IS_FIXED_WIDTH(pFace)) + flag |= FX_FONTSTYLE_FixedPitch; + TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2); + if (!pOS2) + return flag; + if (pOS2->ulCodePageRange1 & (1 << 31)) + flag |= FX_FONTSTYLE_Symbolic; + if (pOS2->panose[0] == 2) { + uint8_t uSerif = pOS2->panose[1]; + if ((uSerif > 1 && uSerif < 10) || uSerif > 13) + flag |= FX_FONTSTYLE_Serif; + } + return flag; +} + +void CFGAS_FontMgr::GetNames(const uint8_t* name_table, + CFX_WideStringArray& Names) { + if (!name_table) { + return; + } + uint8_t* lpTable = (uint8_t*)name_table; + CFX_WideString wsFamily; + uint8_t* sp = lpTable + 2; + uint8_t* lpNameRecord = lpTable + 6; + uint16_t nNameCount = GetUInt16(sp); + uint8_t* lpStr = lpTable + GetUInt16(sp + 2); + for (uint16_t j = 0; j < nNameCount; j++) { + uint16_t nNameID = GetUInt16(lpNameRecord + j * 12 + 6); + if (nNameID != 1) { + continue; + } + uint16_t nPlatformID = GetUInt16(lpNameRecord + j * 12 + 0); + uint16_t nNameLength = GetUInt16(lpNameRecord + j * 12 + 8); + uint16_t nNameOffset = GetUInt16(lpNameRecord + j * 12 + 10); + wsFamily.clear(); + if (nPlatformID != 1) { + for (uint16_t k = 0; k < nNameLength / 2; k++) { + FX_WCHAR wcTemp = GetUInt16(lpStr + nNameOffset + k * 2); + wsFamily += wcTemp; + } + Names.Add(wsFamily); + } else { + for (uint16_t k = 0; k < nNameLength; k++) { + FX_WCHAR wcTemp = GetUInt8(lpStr + nNameOffset + k); + wsFamily += wcTemp; + } + Names.Add(wsFamily); + } + } +} + +// TODO(npm): Get rid of this #define +#define CODEPAGERANGE_IMPLEMENT(n) \ + for (int32_t i = 0; i < 16; i++) { \ + if ((a##n & g_FX_Bit2Charset##n[i].wBit) != 0) \ + charsets.push_back(g_FX_Bit2Charset##n[i].wCharset); \ + } + +std::vector<uint16_t> CFGAS_FontMgr::GetCharsets(FXFT_Face pFace) const { + std::vector<uint16_t> charsets; + TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2); + if (pOS2) { + uint16_t a1 = pOS2->ulCodePageRange1 & 0xffff; + CODEPAGERANGE_IMPLEMENT(1); + uint16_t a2 = (pOS2->ulCodePageRange1 >> 16) & 0xffff; + CODEPAGERANGE_IMPLEMENT(2); + uint16_t a3 = pOS2->ulCodePageRange2 & 0xffff; + CODEPAGERANGE_IMPLEMENT(3); + uint16_t a4 = (pOS2->ulCodePageRange2 >> 16) & 0xffff; + CODEPAGERANGE_IMPLEMENT(4); + } else { + charsets.push_back(FX_CHARSET_Default); + } + return charsets; +} + +#undef CODEPAGERANGE_IMPLEMENT + +void CFGAS_FontMgr::GetUSBCSB(FXFT_Face pFace, uint32_t* USB, uint32_t* CSB) { + TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2); + if (pOS2) { + USB[0] = pOS2->ulUnicodeRange1; + USB[1] = pOS2->ulUnicodeRange2; + USB[2] = pOS2->ulUnicodeRange3; + USB[3] = pOS2->ulUnicodeRange4; + CSB[0] = pOS2->ulCodePageRange1; + CSB[1] = pOS2->ulCodePageRange2; + } else { + USB[0] = 0; + USB[1] = 0; + USB[2] = 0; + USB[3] = 0; + CSB[0] = 0; + CSB[1] = 0; + } +} + +int32_t CFGAS_FontMgr::IsPartName(const CFX_WideString& Name1, + const CFX_WideString& Name2) { + if (Name1.Find(Name2.c_str()) != -1) + return 1; + return 0; +} + +#endif // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ |