| // 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 <algorithm> |
| #include <memory> |
| #include <utility> |
| |
| #include "core/fxcrt/cfx_memorystream.h" |
| #include "core/fxcrt/fx_codepage.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 "third_party/base/stl_util.h" |
| #include "xfa/fgas/font/cfgas_gefont.h" |
| #include "xfa/fgas/font/fgas_fontutils.h" |
| |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ |
| |
| namespace { |
| |
| struct FX_CHARSET_MAP { |
| uint16_t charset; |
| uint16_t codepage; |
| }; |
| |
| const FX_CHARSET_MAP g_FXCharset2CodePageTable[] = { |
| {FX_CHARSET_ANSI, FX_CODEPAGE_MSWin_WesternEuropean}, |
| {FX_CHARSET_Default, FX_CODEPAGE_DefANSI}, |
| {FX_CHARSET_Symbol, FX_CODEPAGE_Symbol}, |
| {FX_CHARSET_MAC_Roman, FX_CODEPAGE_MAC_Roman}, |
| {FX_CHARSET_MAC_ShiftJIS, FX_CODEPAGE_MAC_ShiftJIS}, |
| {FX_CHARSET_MAC_Korean, FX_CODEPAGE_MAC_Korean}, |
| {FX_CHARSET_MAC_ChineseSimplified, FX_CODEPAGE_MAC_ChineseSimplified}, |
| {FX_CHARSET_MAC_ChineseTraditional, FX_CODEPAGE_MAC_ChineseTraditional}, |
| {FX_CHARSET_MAC_Hebrew, FX_CODEPAGE_MAC_Hebrew}, |
| {FX_CHARSET_MAC_Arabic, FX_CODEPAGE_MAC_Arabic}, |
| {FX_CHARSET_MAC_Greek, FX_CODEPAGE_MAC_Greek}, |
| {FX_CHARSET_MAC_Turkish, FX_CODEPAGE_MAC_Turkish}, |
| {FX_CHARSET_MAC_Thai, FX_CODEPAGE_MAC_Thai}, |
| {FX_CHARSET_MAC_EasternEuropean, FX_CODEPAGE_MAC_EasternEuropean}, |
| {FX_CHARSET_MAC_Cyrillic, FX_CODEPAGE_MAC_Cyrillic}, |
| {FX_CHARSET_ShiftJIS, FX_CODEPAGE_ShiftJIS}, |
| {FX_CHARSET_Hangul, FX_CODEPAGE_Hangul}, |
| {FX_CHARSET_Johab, FX_CODEPAGE_Johab}, |
| {FX_CHARSET_ChineseSimplified, FX_CODEPAGE_ChineseSimplified}, |
| {FX_CHARSET_ChineseTraditional, FX_CODEPAGE_ChineseTraditional}, |
| {FX_CHARSET_MSWin_Greek, FX_CODEPAGE_MSWin_Greek}, |
| {FX_CHARSET_MSWin_Turkish, FX_CODEPAGE_MSWin_Turkish}, |
| {FX_CHARSET_MSWin_Vietnamese, FX_CODEPAGE_MSWin_Vietnamese}, |
| {FX_CHARSET_MSWin_Hebrew, FX_CODEPAGE_MSWin_Hebrew}, |
| {FX_CHARSET_MSWin_Arabic, FX_CODEPAGE_MSWin_Arabic}, |
| {FX_CHARSET_MSWin_Baltic, FX_CODEPAGE_MSWin_Baltic}, |
| {FX_CHARSET_MSWin_Cyrillic, FX_CODEPAGE_MSWin_Cyrillic}, |
| {FX_CHARSET_Thai, FX_CODEPAGE_MSDOS_Thai}, |
| {FX_CHARSET_MSWin_EasternEuropean, FX_CODEPAGE_MSWin_EasternEuropean}, |
| {FX_CHARSET_US, FX_CODEPAGE_MSDOS_US}, |
| {FX_CHARSET_OEM, FX_CODEPAGE_MSDOS_WesternEuropean}, |
| }; |
| |
| uint16_t GetCodePageFromCharset(uint8_t charset) { |
| int32_t iEnd = sizeof(g_FXCharset2CodePageTable) / sizeof(FX_CHARSET_MAP) - 1; |
| ASSERT(iEnd >= 0); |
| |
| int32_t iStart = 0, iMid; |
| do { |
| iMid = (iStart + iEnd) / 2; |
| const FX_CHARSET_MAP& cp = g_FXCharset2CodePageTable[iMid]; |
| if (charset == cp.charset) |
| return cp.codepage; |
| if (charset < cp.charset) |
| iEnd = iMid - 1; |
| else |
| iStart = iMid + 1; |
| } while (iStart <= iEnd); |
| return 0xFFFF; |
| } |
| |
| 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; |
| } |
| |
| const FX_FONTDESCRIPTOR* MatchDefaultFont( |
| FX_FONTMATCHPARAMS* pParams, |
| const std::deque<FX_FONTDESCRIPTOR>& fonts) { |
| const FX_FONTDESCRIPTOR* pBestFont = nullptr; |
| int32_t iBestSimilar = 0; |
| bool bMatchStyle = (pParams->dwMatchFlags & FX_FONTMATCHPARA_MatchStyle) > 0; |
| for (const auto& font : fonts) { |
| if ((font.dwFontStyles & FX_FONTSTYLE_BoldItalic) == |
| FX_FONTSTYLE_BoldItalic) { |
| continue; |
| } |
| if (pParams->pwsFamily) { |
| if (FXSYS_wcsicmp(pParams->pwsFamily, font.wsFontFace)) |
| continue; |
| if (font.uCharSet == FX_CHARSET_Symbol) |
| return &font; |
| } |
| if (font.uCharSet == FX_CHARSET_Symbol) |
| continue; |
| if (pParams->wCodePage != 0xFFFF) { |
| if (GetCodePageFromCharset(font.uCharSet) != pParams->wCodePage) |
| continue; |
| } else { |
| if (pParams->dwUSB < 128) { |
| uint32_t dwByte = pParams->dwUSB / 32; |
| uint32_t dwUSB = 1 << (pParams->dwUSB % 32); |
| if ((font.FontSignature.fsUsb[dwByte] & dwUSB) == 0) |
| continue; |
| } |
| } |
| if (bMatchStyle) { |
| if ((font.dwFontStyles & 0x0F) == (pParams->dwFontStyles & 0x0F)) |
| return &font; |
| continue; |
| } |
| if (pParams->pwsFamily) { |
| if (FXSYS_wcsicmp(pParams->pwsFamily, font.wsFontFace) == 0) |
| return &font; |
| } |
| int32_t iSimilarValue = GetSimilarityScore(&font, pParams->dwFontStyles); |
| if (iBestSimilar < iSimilarValue) { |
| iBestSimilar = iSimilarValue; |
| pBestFont = &font; |
| } |
| } |
| return iBestSimilar < 1 ? nullptr : pBestFont; |
| } |
| |
| uint32_t GetFontHashCode(uint16_t wCodePage, uint32_t dwFontStyles) { |
| uint32_t dwHash = wCodePage; |
| if (dwFontStyles & FX_FONTSTYLE_FixedPitch) |
| dwHash |= 0x00010000; |
| if (dwFontStyles & FX_FONTSTYLE_Serif) |
| dwHash |= 0x00020000; |
| if (dwFontStyles & FX_FONTSTYLE_Symbolic) |
| dwHash |= 0x00040000; |
| if (dwFontStyles & FX_FONTSTYLE_Script) |
| dwHash |= 0x00080000; |
| if (dwFontStyles & FX_FONTSTYLE_Italic) |
| dwHash |= 0x00100000; |
| if (dwFontStyles & FX_FONTSTYLE_Bold) |
| dwHash |= 0x00200000; |
| return dwHash; |
| } |
| |
| uint32_t GetFontFamilyHash(const wchar_t* pszFontFamily, |
| uint32_t dwFontStyles, |
| uint16_t wCodePage) { |
| CFX_WideString wsFont(pszFontFamily); |
| if (dwFontStyles & FX_FONTSTYLE_Bold) |
| wsFont += L"Bold"; |
| if (dwFontStyles & FX_FONTSTYLE_Italic) |
| wsFont += L"Italic"; |
| |
| wsFont += wCodePage; |
| return FX_HashCode_GetW(wsFont.AsStringC(), false); |
| } |
| |
| } // 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) { |
| if (m_pEnumerator) |
| m_pEnumerator(&m_FontFaces, nullptr, 0xFEFF); |
| } |
| |
| CFGAS_FontMgr::~CFGAS_FontMgr() {} |
| |
| CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::GetFontByCodePage( |
| uint16_t wCodePage, |
| uint32_t dwFontStyles, |
| const wchar_t* pszFontFamily) { |
| uint32_t dwHash = GetFontHashCode(wCodePage, dwFontStyles); |
| auto it = m_CPFonts.find(dwHash); |
| if (it != m_CPFonts.end()) { |
| return it->second ? LoadFont(it->second, dwFontStyles, wCodePage) : nullptr; |
| } |
| const FX_FONTDESCRIPTOR* 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; |
| |
| CFX_RetainPtr<CFGAS_GEFont> pFont = |
| CFGAS_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this); |
| if (!pFont) |
| return nullptr; |
| |
| m_Fonts.push_back(pFont); |
| m_CPFonts[dwHash] = pFont; |
| dwHash = GetFontFamilyHash(pFD->wsFontFace, dwFontStyles, wCodePage); |
| m_FamilyFonts[dwHash] = pFont; |
| return LoadFont(pFont, dwFontStyles, wCodePage); |
| } |
| |
| CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::GetFontByUnicode( |
| wchar_t wUnicode, |
| uint32_t dwFontStyles, |
| const wchar_t* pszFontFamily) { |
| const FGAS_FONTUSB* pRet = FGAS_GetUnicodeBitField(wUnicode); |
| if (pRet->wBitField == 999) |
| return nullptr; |
| |
| uint32_t dwHash = |
| GetFontFamilyHash(pszFontFamily, dwFontStyles, pRet->wBitField); |
| auto it = m_UnicodeFonts.find(dwHash); |
| if (it != m_UnicodeFonts.end()) { |
| return it->second ? LoadFont(it->second, dwFontStyles, pRet->wCodePage) |
| : nullptr; |
| } |
| const FX_FONTDESCRIPTOR* 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 = GetCodePageFromCharset(pFD->uCharSet); |
| const wchar_t* pFontFace = pFD->wsFontFace; |
| CFX_RetainPtr<CFGAS_GEFont> pFont = |
| CFGAS_GEFont::LoadFont(pFontFace, dwFontStyles, wCodePage, this); |
| if (!pFont) |
| return nullptr; |
| |
| m_Fonts.push_back(pFont); |
| m_UnicodeFonts[dwHash] = pFont; |
| m_CPFonts[GetFontHashCode(wCodePage, dwFontStyles)] = pFont; |
| m_FamilyFonts[GetFontFamilyHash(pFontFace, dwFontStyles, wCodePage)] = pFont; |
| return LoadFont(pFont, dwFontStyles, wCodePage); |
| } |
| |
| CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::LoadFont( |
| const wchar_t* pszFontFamily, |
| uint32_t dwFontStyles, |
| uint16_t wCodePage) { |
| CFX_RetainPtr<CFGAS_GEFont> pFont; |
| uint32_t dwHash = GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage); |
| auto it = m_FamilyFonts.find(dwHash); |
| if (it != m_FamilyFonts.end()) |
| return it->second ? LoadFont(it->second, dwFontStyles, wCodePage) : nullptr; |
| |
| const FX_FONTDESCRIPTOR* pFD = |
| FindFont(pszFontFamily, dwFontStyles, true, wCodePage); |
| if (!pFD) |
| pFD = FindFont(pszFontFamily, dwFontStyles, false, wCodePage); |
| if (!pFD) |
| return nullptr; |
| |
| if (wCodePage == 0xFFFF) |
| wCodePage = GetCodePageFromCharset(pFD->uCharSet); |
| |
| pFont = |
| CFGAS_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this); |
| if (!pFont) |
| return nullptr; |
| |
| m_Fonts.push_back(pFont); |
| m_FamilyFonts[dwHash] = pFont; |
| dwHash = GetFontHashCode(wCodePage, dwFontStyles); |
| m_CPFonts[dwHash] = pFont; |
| return LoadFont(pFont, dwFontStyles, wCodePage); |
| } |
| |
| CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::LoadFont( |
| const CFX_RetainPtr<CFGAS_GEFont>& pSrcFont, |
| uint32_t dwFontStyles, |
| uint16_t wCodePage) { |
| if (pSrcFont->GetFontStyles() == dwFontStyles) |
| return pSrcFont; |
| |
| void* buffer[3] = {pSrcFont.Get(), (void*)(uintptr_t)dwFontStyles, |
| (void*)(uintptr_t)wCodePage}; |
| uint32_t dwHash = FX_HashCode_GetA( |
| CFX_ByteStringC((uint8_t*)buffer, sizeof(buffer)), false); |
| auto it = m_DeriveFonts.find(dwHash); |
| if (it != m_DeriveFonts.end() && it->second) |
| return it->second; |
| |
| CFX_RetainPtr<CFGAS_GEFont> pFont = pSrcFont->Derive(dwFontStyles, wCodePage); |
| if (!pFont) |
| return nullptr; |
| |
| m_DeriveFonts[dwHash] = pFont; |
| auto iter = std::find(m_Fonts.begin(), m_Fonts.end(), pFont); |
| if (iter == m_Fonts.end()) |
| m_Fonts.push_back(pFont); |
| return pFont; |
| } |
| |
| void CFGAS_FontMgr::RemoveFont( |
| std::map<uint32_t, CFX_RetainPtr<CFGAS_GEFont>>* pFontMap, |
| const CFX_RetainPtr<CFGAS_GEFont>& pFont) { |
| auto iter = pFontMap->begin(); |
| while (iter != pFontMap->end()) { |
| auto old_iter = iter++; |
| if (old_iter->second == pFont) |
| pFontMap->erase(old_iter); |
| } |
| } |
| |
| void CFGAS_FontMgr::RemoveFont(const CFX_RetainPtr<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); |
| auto it = std::find(m_Fonts.begin(), m_Fonts.end(), pFont); |
| if (it != m_Fonts.end()) |
| m_Fonts.erase(it); |
| } |
| |
| const FX_FONTDESCRIPTOR* CFGAS_FontMgr::FindFont(const wchar_t* pszFontFamily, |
| uint32_t dwFontStyles, |
| uint32_t dwMatchFlags, |
| uint16_t wCodePage, |
| uint32_t dwUSB, |
| wchar_t wUnicode) { |
| FX_FONTMATCHPARAMS params; |
| memset(¶ms, 0, sizeof(params)); |
| params.dwUSB = dwUSB; |
| params.wUnicode = wUnicode; |
| params.wCodePage = wCodePage; |
| params.pwsFamily = pszFontFamily; |
| params.dwFontStyles = dwFontStyles; |
| params.dwMatchFlags = dwMatchFlags; |
| const FX_FONTDESCRIPTOR* pDesc = MatchDefaultFont(¶ms, m_FontFaces); |
| if (pDesc) |
| return pDesc; |
| |
| if (!pszFontFamily || !m_pEnumerator) |
| return nullptr; |
| |
| std::deque<FX_FONTDESCRIPTOR> namedFonts; |
| m_pEnumerator(&namedFonts, pszFontFamily, wUnicode); |
| params.pwsFamily = nullptr; |
| pDesc = MatchDefaultFont(¶ms, namedFonts); |
| if (!pDesc) |
| return nullptr; |
| |
| auto it = std::find(m_FontFaces.rbegin(), m_FontFaces.rend(), *pDesc); |
| if (it != m_FontFaces.rend()) |
| return &*it; |
| |
| m_FontFaces.push_back(*pDesc); |
| return &m_FontFaces.back(); |
| } |
| |
| 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); |
| memset(pFont, 0, sizeof(FX_FONTDESCRIPTOR)); |
| pFont->uCharSet = lf.lfCharSet; |
| pFont->dwFontStyles = FX_GetGdiFontStyles(lf); |
| FXSYS_wcsncpy(pFont->wsFontFace, (const wchar_t*)lf.lfFaceName, 31); |
| pFont->wsFontFace[31] = 0; |
| memcpy(&pFont->FontSignature, &lpntme->ntmFontSig, |
| sizeof(lpntme->ntmFontSig)); |
| reinterpret_cast<std::deque<FX_FONTDESCRIPTOR>*>(lParam)->push_back(*pFont); |
| FX_Free(pFont); |
| return 1; |
| } |
| |
| static void FX_EnumGdiFonts(std::deque<FX_FONTDESCRIPTOR>* fonts, |
| const wchar_t* pwsFaceName, |
| wchar_t wUnicode) { |
| HDC hDC = ::GetDC(nullptr); |
| LOGFONTW lfFind; |
| 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 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 |
| }; |
| |
| const uint16_t g_CodePages[] = {FX_CODEPAGE_MSWin_WesternEuropean, |
| FX_CODEPAGE_MSWin_EasternEuropean, |
| FX_CODEPAGE_MSWin_Cyrillic, |
| FX_CODEPAGE_MSWin_Greek, |
| FX_CODEPAGE_MSWin_Turkish, |
| FX_CODEPAGE_MSWin_Hebrew, |
| FX_CODEPAGE_MSWin_Arabic, |
| FX_CODEPAGE_MSWin_Baltic, |
| FX_CODEPAGE_MSWin_Vietnamese, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_MSDOS_Thai, |
| FX_CODEPAGE_ShiftJIS, |
| FX_CODEPAGE_ChineseSimplified, |
| FX_CODEPAGE_Hangul, |
| FX_CODEPAGE_ChineseTraditional, |
| FX_CODEPAGE_Johab, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_DefANSI, |
| FX_CODEPAGE_MSDOS_Greek2, |
| FX_CODEPAGE_MSDOS_Russian, |
| FX_CODEPAGE_MSDOS_Norwegian, |
| FX_CODEPAGE_MSDOS_Arabic, |
| FX_CODEPAGE_MSDOS_FrenchCanadian, |
| FX_CODEPAGE_MSDOS_Hebrew, |
| FX_CODEPAGE_MSDOS_Icelandic, |
| FX_CODEPAGE_MSDOS_Portuguese, |
| FX_CODEPAGE_MSDOS_Turkish, |
| FX_CODEPAGE_MSDOS_Cyrillic, |
| FX_CODEPAGE_MSDOS_EasternEuropean, |
| FX_CODEPAGE_MSDOS_Baltic, |
| FX_CODEPAGE_MSDOS_Greek1, |
| FX_CODEPAGE_Arabic_ASMO708, |
| FX_CODEPAGE_MSDOS_WesternEuropean, |
| FX_CODEPAGE_MSDOS_US}; |
| |
| uint16_t FX_GetCodePageBit(uint16_t wCodePage) { |
| for (size_t i = 0; i < FX_ArraySize(g_CodePages); ++i) { |
| if (g_CodePages[i] == wCodePage) |
| return static_cast<uint16_t>(i); |
| } |
| return static_cast<uint16_t>(-1); |
| } |
| |
| uint16_t FX_GetUnicodeBit(wchar_t 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<uint16_t>(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_EasternEuropean}, |
| {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_Hangul}, |
| {1 << 4, FX_CHARSET_ChineseTraditional}, |
| {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.push_back(g_FontFolders[i]); |
| } |
| |
| CFX_FontSourceEnum_File::~CFX_FontSourceEnum_File() {} |
| |
| CFX_ByteString CFX_FontSourceEnum_File::GetNextFile() { |
| FX_FileHandle* pCurHandle = |
| !m_FolderQueue.empty() ? m_FolderQueue.back().pFileHandle : nullptr; |
| if (!pCurHandle) { |
| if (m_FolderPaths.empty()) |
| return ""; |
| pCurHandle = FX_OpenFolder(m_FolderPaths.back().c_str()); |
| FX_HandleParentPath hpp; |
| hpp.pFileHandle = pCurHandle; |
| hpp.bsParentPath = m_FolderPaths.back(); |
| m_FolderQueue.push_back(hpp); |
| } |
| CFX_ByteString bsName; |
| bool bFolder; |
| CFX_ByteString bsFolderSeparator = |
| CFX_ByteString::FromUnicode(CFX_WideString(FX_GetFolderSeparator())); |
| while (true) { |
| if (!FX_GetNextFile(pCurHandle, &bsName, &bFolder)) { |
| FX_CloseFolder(pCurHandle); |
| if (!m_FolderQueue.empty()) |
| m_FolderQueue.pop_back(); |
| if (m_FolderQueue.empty()) { |
| if (!m_FolderPaths.empty()) |
| m_FolderPaths.pop_back(); |
| return !m_FolderPaths.empty() ? GetNextFile() : ""; |
| } |
| pCurHandle = m_FolderQueue.back().pFileHandle; |
| continue; |
| } |
| if (bsName == "." || bsName == "..") |
| continue; |
| if (bFolder) { |
| FX_HandleParentPath hpp; |
| hpp.bsParentPath = |
| m_FolderQueue.back().bsParentPath + bsFolderSeparator + bsName; |
| hpp.pFileHandle = FX_OpenFolder(hpp.bsParentPath.c_str()); |
| if (!hpp.pFileHandle) |
| continue; |
| m_FolderQueue.push_back(hpp); |
| pCurHandle = hpp.pFileHandle; |
| continue; |
| } |
| bsName = m_FolderQueue.back().bsParentPath + bsFolderSeparator + bsName; |
| break; |
| } |
| return bsName; |
| } |
| |
| bool CFX_FontSourceEnum_File::HasStartPosition() { |
| m_wsNext = GetNextFile().UTF8Decode(); |
| return m_wsNext.GetLength() != 0; |
| } |
| |
| CFX_RetainPtr<CFX_CRTFileAccess> CFX_FontSourceEnum_File::GetNext() { |
| if (m_wsNext.GetLength() == 0) |
| return nullptr; |
| |
| auto pAccess = pdfium::MakeRetain<CFX_CRTFileAccess>(m_wsNext.AsStringC()); |
| m_wsNext = GetNextFile().UTF8Decode(); |
| 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() {} |
| |
| 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) { |
| CFX_RetainPtr<IFX_SeekableReadStream> pFontStream = |
| CreateFontStream(pFontMapper, pSystemFontInfo, i); |
| if (!pFontStream) |
| continue; |
| |
| CFX_WideString wsFaceName = |
| CFX_WideString::FromLocal(pFontMapper->GetFaceName(i).c_str()); |
| RegisterFaces(pFontStream, &wsFaceName); |
| } |
| return !m_InstalledFonts.empty(); |
| } |
| |
| bool CFGAS_FontMgr::EnumFontsFromFiles() { |
| CFX_GEModule::Get()->GetFontMgr()->InitFTLibrary(); |
| if (!m_pFontSource->HasStartPosition()) |
| return !m_InstalledFonts.empty(); |
| |
| while (CFX_RetainPtr<CFX_CRTFileAccess> pFontSource = |
| m_pFontSource->GetNext()) { |
| CFX_RetainPtr<IFX_SeekableReadStream> pFontStream = |
| pFontSource->CreateFileStream(FX_FILEMODE_ReadOnly); |
| if (pFontStream) |
| RegisterFaces(pFontStream, nullptr); |
| } |
| return !m_InstalledFonts.empty(); |
| } |
| |
| bool CFGAS_FontMgr::EnumFonts() { |
| return EnumFontsFromFontMapper() || EnumFontsFromFiles(); |
| } |
| |
| CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::LoadFont( |
| const wchar_t* pszFontFamily, |
| uint32_t dwFontStyles, |
| uint16_t wCodePage) { |
| return GetFontByCodePage(wCodePage, dwFontStyles, pszFontFamily); |
| } |
| |
| CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::GetFontByCodePage( |
| uint16_t wCodePage, |
| uint32_t dwFontStyles, |
| const wchar_t* pszFontFamily) { |
| CFX_ByteString bsHash; |
| bsHash.Format("%d, %d", wCodePage, dwFontStyles); |
| bsHash += FX_UTF8Encode(CFX_WideStringC(pszFontFamily)); |
| uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false); |
| std::vector<CFX_RetainPtr<CFGAS_GEFont>>* pFontArray = &m_Hash2Fonts[dwHash]; |
| if (!pFontArray->empty()) |
| return (*pFontArray)[0]; |
| |
| std::vector<CFX_FontDescriptorInfo>* sortedFontInfos = |
| m_Hash2CandidateList[dwHash].get(); |
| if (!sortedFontInfos) { |
| auto pNewFonts = pdfium::MakeUnique<std::vector<CFX_FontDescriptorInfo>>(); |
| sortedFontInfos = pNewFonts.get(); |
| MatchFonts(sortedFontInfos, wCodePage, dwFontStyles, |
| CFX_WideString(pszFontFamily), 0); |
| m_Hash2CandidateList[dwHash] = std::move(pNewFonts); |
| } |
| if (sortedFontInfos->empty()) |
| return nullptr; |
| |
| CFX_FontDescriptor* pDesc = (*sortedFontInfos)[0].pFont; |
| CFX_RetainPtr<CFGAS_GEFont> pFont = |
| LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr); |
| if (!pFont) |
| return nullptr; |
| |
| pFont->SetLogicalFontStyle(dwFontStyles); |
| pFontArray->push_back(pFont); |
| return pFont; |
| } |
| |
| CFX_RetainPtr<CFGAS_GEFont> CFGAS_FontMgr::GetFontByUnicode( |
| wchar_t wUnicode, |
| uint32_t dwFontStyles, |
| const wchar_t* pszFontFamily) { |
| if (pdfium::ContainsKey(m_FailedUnicodesSet, wUnicode)) |
| 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 += FX_UTF8Encode(CFX_WideStringC(pszFontFamily)); |
| uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false); |
| std::vector<CFX_RetainPtr<CFGAS_GEFont>>* pFonts = &m_Hash2Fonts[dwHash]; |
| for (size_t i = 0; i < pFonts->size(); ++i) { |
| if (VerifyUnicode((*pFonts)[i], wUnicode)) |
| return (*pFonts)[i]; |
| } |
| std::vector<CFX_FontDescriptorInfo>* sortedFontInfos = |
| m_Hash2CandidateList[dwHash].get(); |
| if (!sortedFontInfos) { |
| auto pNewFonts = pdfium::MakeUnique<std::vector<CFX_FontDescriptorInfo>>(); |
| sortedFontInfos = pNewFonts.get(); |
| MatchFonts(sortedFontInfos, wCodePage, dwFontStyles, |
| CFX_WideString(pszFontFamily), wUnicode); |
| m_Hash2CandidateList[dwHash] = std::move(pNewFonts); |
| } |
| for (const auto& info : *sortedFontInfos) { |
| CFX_FontDescriptor* pDesc = info.pFont; |
| if (!VerifyUnicode(pDesc, wUnicode)) |
| continue; |
| CFX_RetainPtr<CFGAS_GEFont> pFont = |
| LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr); |
| if (!pFont) |
| continue; |
| pFont->SetLogicalFontStyle(dwFontStyles); |
| pFonts->push_back(pFont); |
| return pFont; |
| } |
| if (!pszFontFamily) |
| m_FailedUnicodesSet.insert(wUnicode); |
| return nullptr; |
| } |
| |
| bool CFGAS_FontMgr::VerifyUnicode(CFX_FontDescriptor* pDesc, |
| wchar_t wcUnicode) { |
| CFX_RetainPtr<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); |
| 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(const CFX_RetainPtr<CFGAS_GEFont>& pFont, |
| wchar_t 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; |
| } |
| |
| CFX_RetainPtr<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; |
| |
| CFX_RetainPtr<IFX_SeekableReadStream> pFontStream = |
| CreateFontStream(wsFaceName.UTF8Encode()); |
| if (!pFontStream) |
| return nullptr; |
| |
| auto pInternalFont = pdfium::MakeUnique<CFX_Font>(); |
| if (!pInternalFont->LoadFile(pFontStream, iFaceIndex)) |
| return nullptr; |
| |
| CFX_RetainPtr<CFGAS_GEFont> pFont = |
| CFGAS_GEFont::LoadFont(std::move(pInternalFont), this); |
| if (!pFont) |
| return nullptr; |
| |
| m_IFXFont2FileRead[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 = |
| static_cast<IFX_SeekableReadStream*>(stream->descriptor.pointer); |
| if (!pFile->ReadBlock(buffer, offset, count)) |
| return 0; |
| |
| return count; |
| } |
| |
| void _ftStreamClose(FXFT_Stream stream) {} |
| |
| }; // extern "C" |
| |
| FXFT_Face CFGAS_FontMgr::LoadFace( |
| const CFX_RetainPtr<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; |
| |
| // TODO(palmer): This memory will be freed with |ft_free| (which is |free|). |
| // Ultimately, we want to change this to: |
| // FXFT_Stream ftStream = FX_Alloc(FXFT_StreamRec, 1); |
| // https://bugs.chromium.org/p/pdfium/issues/detail?id=690 |
| FXFT_Stream ftStream = |
| static_cast<FXFT_Stream>(ft_scalloc(sizeof(FXFT_StreamRec), 1)); |
| memset(ftStream, 0, sizeof(FXFT_StreamRec)); |
| ftStream->base = nullptr; |
| ftStream->descriptor.pointer = static_cast<void*>(pFontStream.Get()); |
| ftStream->pos = 0; |
| ftStream->size = static_cast<unsigned long>(pFontStream->GetSize()); |
| ftStream->read = _ftStreamRead; |
| ftStream->close = _ftStreamClose; |
| |
| FXFT_Open_Args ftArgs; |
| 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)) { |
| ft_sfree(ftStream); |
| return nullptr; |
| } |
| |
| FXFT_Set_Pixel_Sizes(pFace, 0, 64); |
| return pFace; |
| } |
| |
| CFX_RetainPtr<IFX_SeekableReadStream> CFGAS_FontMgr::CreateFontStream( |
| CFX_FontMapper* pFontMapper, |
| IFX_SystemFontInfo* pSystemFontInfo, |
| uint32_t index) { |
| int iExact = 0; |
| void* hFont = |
| pSystemFontInfo->MapFont(0, 0, FX_CHARSET_Default, 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 pdfium::MakeRetain<CFX_MemoryStream>(pBuffer, dwFileSize, true); |
| } |
| |
| CFX_RetainPtr<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; |
| } |
| |
| void CFGAS_FontMgr::MatchFonts( |
| std::vector<CFX_FontDescriptorInfo>* pMatchedFonts, |
| uint16_t wCodePage, |
| uint32_t dwFontStyles, |
| const CFX_WideString& FontName, |
| wchar_t wcUnicode) { |
| pMatchedFonts->clear(); |
| for (const auto& pFont : m_InstalledFonts) { |
| int32_t nPenalty = |
| CalcPenalty(pFont.get(), wCodePage, dwFontStyles, FontName, wcUnicode); |
| if (nPenalty >= 0xffff) |
| continue; |
| pMatchedFonts->push_back({pFont.get(), nPenalty}); |
| if (pMatchedFonts->size() == 0xffff) |
| break; |
| } |
| std::sort(pMatchedFonts->begin(), pMatchedFonts->end()); |
| } |
| |
| int32_t CFGAS_FontMgr::CalcPenalty(CFX_FontDescriptor* pInstalled, |
| uint16_t wCodePage, |
| uint32_t dwFontStyles, |
| const CFX_WideString& FontName, |
| wchar_t wcUnicode) { |
| int32_t nPenalty = 30000; |
| if (FontName.GetLength() != 0) { |
| if (FontName != pInstalled->m_wsFaceName) { |
| size_t i; |
| for (i = 0; i < pInstalled->m_wsFamilyNames.size(); ++i) { |
| if (pInstalled->m_wsFamilyNames[i] == FontName) |
| break; |
| } |
| if (i == pInstalled->m_wsFamilyNames.size()) |
| nPenalty += 0xFFFF; |
| else |
| nPenalty -= 28000; |
| } else { |
| nPenalty -= 30000; |
| } |
| if (30000 == nPenalty && |
| 0 == IsPartName(pInstalled->m_wsFaceName, FontName)) { |
| size_t i; |
| for (i = 0; i < pInstalled->m_wsFamilyNames.size(); i++) { |
| if (IsPartName(pInstalled->m_wsFamilyNames[i], FontName) != 0) |
| break; |
| } |
| if (i == pInstalled->m_wsFamilyNames.size()) |
| 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 == FX_CODEPAGE_DefANSI || wCodePage == 0xFFFF) |
| ? static_cast<uint16_t>(-1) |
| : FX_GetCodePageBit(wCodePage); |
| if (wBit != static_cast<uint16_t>(-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<uint16_t>(999) |
| : FX_GetUnicodeBit(wcUnicode); |
| if (wBit != static_cast<uint16_t>(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(const CFX_RetainPtr<CFGAS_GEFont>& pEFont) { |
| if (!pEFont) |
| return; |
| |
| m_IFXFont2FileRead.erase(pEFont); |
| |
| auto iter = m_Hash2Fonts.begin(); |
| while (iter != m_Hash2Fonts.end()) { |
| auto old_iter = iter++; |
| bool all_empty = true; |
| for (size_t i = 0; i < old_iter->second.size(); i++) { |
| if (old_iter->second[i] == pEFont) |
| old_iter->second[i].Reset(); |
| else if (old_iter->second[i]) |
| all_empty = false; |
| } |
| if (all_empty) |
| m_Hash2Fonts.erase(old_iter); |
| } |
| } |
| |
| void CFGAS_FontMgr::RegisterFace(FXFT_Face pFace, |
| const CFX_WideString* pFaceName) { |
| if ((pFace->face_flags & FT_FACE_FLAG_SCALABLE) == 0) |
| return; |
| |
| auto pFont = pdfium::MakeUnique<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.push_back( |
| 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.push_back(std::move(pFont)); |
| } |
| |
| void CFGAS_FontMgr::RegisterFaces( |
| const CFX_RetainPtr<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, |
| std::vector<CFX_WideString>& 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++) { |
| wchar_t wcTemp = GetUInt16(lpStr + nNameOffset + k * 2); |
| wsFamily += wcTemp; |
| } |
| Names.push_back(wsFamily); |
| continue; |
| } |
| for (uint16_t k = 0; k < nNameLength; k++) { |
| wchar_t wcTemp = GetUInt8(lpStr + nNameOffset + k); |
| wsFamily += wcTemp; |
| } |
| Names.push_back(wsFamily); |
| } |
| } |
| |
| 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) { |
| 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_ |
