// 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::Create( FX_LPEnumAllFonts pEnumerator) { return pdfium::MakeUnique(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::GetFontByCodePage(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) return nullptr; 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); } CFGAS_GEFont* CFGAS_FontMgr::GetFontByUnicode(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) return nullptr; 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); } 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) return nullptr; 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); } 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) return nullptr; 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; } 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) return nullptr; 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); } 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 static_cast(-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 p[0]; } inline uint16_t GetUInt16(const uint8_t* p) { return static_cast(p[0] << 8 | p[1]); } struct FX_BIT2CHARSET { uint16_t wBit; uint16_t wCharset; }; const FX_BIT2CHARSET g_FX_Bit2Charset[4][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}}, {{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}}, {{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}}, {{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::Create( CFX_FontSourceEnum_File* pFontEnum) { if (!pFontEnum) return nullptr; auto pFontMgr = pdfium::MakeUnique(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* 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* 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; 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* 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; 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 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 = static_cast(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 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 (FontName.GetLength() != 0) { 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 (IsPartName(pInstalled->m_wsFamilyNames[i], FontName) != 0) 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 = (wCodePage == 0 || wCodePage == 0xFFFF) ? static_cast(-1) : FX_GetCodePageBit(wCodePage); if (wBit != static_cast(-1)) { ASSERT(wBit < 64); if ((pInstalled->m_dwCsb[wBit / 32] & (1 << (wBit % 32))) == 0) nPenalty += 0xFFFF; else nPenalty -= 60000; } wBit = (wcUnicode == 0 || wcUnicode == 0xFFFE) ? static_cast(999) : FX_GetUnicodeBit(wcUnicode); if (wBit != static_cast(999)) { ASSERT(wBit < 128); if ((pInstalled->m_dwUsb[wBit / 32] & (1 << (wBit % 32))) == 0) nPenalty += 0xFFFF; else nPenalty -= 60000; } return nPenalty; } 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* 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 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 charsets = GetCharsets(pFace); GetUSBCSB(pFace, pFont->m_dwUsb, pFont->m_dwCsb); FT_ULong dwTag; FT_ENC_TAG(dwTag, 'n', 'a', 'm', 'e'); std::vector 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); continue; } for (uint16_t k = 0; k < nNameLength; k++) { FX_WCHAR wcTemp = GetUInt8(lpStr + nNameOffset + k); wsFamily += wcTemp; } Names.Add(wsFamily); } } std::vector CFGAS_FontMgr::GetCharsets(FXFT_Face pFace) const { std::vector charsets; TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2); if (!pOS2) { charsets.push_back(FX_CHARSET_Default); return charsets; } uint16_t a[4] = { pOS2->ulCodePageRange1 & 0xffff, (pOS2->ulCodePageRange1 >> 16) & 0xffff, pOS2->ulCodePageRange2 & 0xffff, (pOS2->ulCodePageRange2 >> 16) & 0xffff}; for (int n = 0; n < 4; 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); } } return charsets; } 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] = 0; USB[1] = 0; USB[2] = 0; USB[3] = 0; CSB[0] = 0; CSB[1] = 0; return; } USB[0] = pOS2->ulUnicodeRange1; USB[1] = pOS2->ulUnicodeRange2; USB[2] = pOS2->ulUnicodeRange3; USB[3] = pOS2->ulUnicodeRange4; CSB[0] = pOS2->ulCodePageRange1; CSB[1] = pOS2->ulCodePageRange2; } 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_