From 8f3eb6051c0465923d6694bd0f0b6dc5bb51cbe3 Mon Sep 17 00:00:00 2001 From: npm Date: Fri, 11 Nov 2016 17:16:23 -0800 Subject: Remove IFGAS_FontMgr and clean up (the renamed) CFGAS_FontMgr a little. IFGAS_FontMgr is an interface only for a class only defined on Windows, plus a class only defined for non-Windows. I'm removing the interface, renaming the class to have the same name in both cases, and cleaning up a bit of unused methods. Review-Url: https://codereview.chromium.org/2494883002 --- BUILD.gn | 5 +- xfa/fde/css/cfde_cssrulecollection.cpp | 4 +- xfa/fde/css/fde_css.h | 2 +- xfa/fde/css/fde_cssstyleselector.cpp | 2 +- xfa/fde/css/fde_cssstyleselector.h | 8 +- xfa/fde/fde_gedevice.cpp | 2 +- xfa/fde/fde_visualset.h | 2 +- xfa/fde/ifde_txtedtengine.h | 2 +- xfa/fde/tto/fde_textout.h | 2 +- xfa/fgas/font/cfgas_fontmgr.cpp | 1282 +++++++++++++++++++++++++++++ xfa/fgas/font/cfgas_fontmgr.h | 264 ++++++ xfa/fgas/font/fgas_font.h | 165 ---- xfa/fgas/font/fgas_fontutils.cpp | 2 +- xfa/fgas/font/fgas_gefont.cpp | 12 +- xfa/fgas/font/fgas_gefont.h | 16 +- xfa/fgas/font/fgas_stdfontmgr.cpp | 1384 -------------------------------- xfa/fgas/font/fgas_stdfontmgr.h | 222 ----- xfa/fgas/layout/fgas_unicode.h | 2 +- xfa/fwl/theme/cfwl_widgettp.cpp | 6 +- xfa/fwl/theme/cfwl_widgettp.h | 4 +- xfa/fxfa/app/xfa_ffapp.cpp | 8 +- xfa/fxfa/app/xfa_fontmgr.cpp | 6 +- xfa/fxfa/app/xfa_textlayout.cpp | 2 +- xfa/fxfa/xfa_ffapp.h | 6 +- xfa/fxfa/xfa_fontmgr.h | 2 +- 25 files changed, 1593 insertions(+), 1819 deletions(-) create mode 100644 xfa/fgas/font/cfgas_fontmgr.cpp create mode 100644 xfa/fgas/font/cfgas_fontmgr.h delete mode 100644 xfa/fgas/font/fgas_font.h delete mode 100644 xfa/fgas/font/fgas_stdfontmgr.cpp delete mode 100644 xfa/fgas/font/fgas_stdfontmgr.h diff --git a/BUILD.gn b/BUILD.gn index 322c319ef4..c83854e2c1 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -1145,13 +1145,12 @@ if (pdf_enable_xfa) { "xfa/fgas/crt/fgas_stream.h", "xfa/fgas/crt/fgas_utils.cpp", "xfa/fgas/crt/fgas_utils.h", - "xfa/fgas/font/fgas_font.h", + "xfa/fgas/font/cfgas_fontmgr.cpp", + "xfa/fgas/font/cfgas_fontmgr.h", "xfa/fgas/font/fgas_fontutils.cpp", "xfa/fgas/font/fgas_fontutils.h", "xfa/fgas/font/fgas_gefont.cpp", "xfa/fgas/font/fgas_gefont.h", - "xfa/fgas/font/fgas_stdfontmgr.cpp", - "xfa/fgas/font/fgas_stdfontmgr.h", "xfa/fgas/layout/fgas_linebreak.cpp", "xfa/fgas/layout/fgas_linebreak.h", "xfa/fgas/layout/fgas_rtfbreak.cpp", diff --git a/xfa/fde/css/cfde_cssrulecollection.cpp b/xfa/fde/css/cfde_cssrulecollection.cpp index 70cc655a56..28a482b834 100644 --- a/xfa/fde/css/cfde_cssrulecollection.cpp +++ b/xfa/fde/css/cfde_cssrulecollection.cpp @@ -39,7 +39,7 @@ CFDE_CSSRuleCollection::~CFDE_CSSRuleCollection() { void CFDE_CSSRuleCollection::AddRulesFrom(const CFDE_CSSStyleSheetArray& sheets, uint32_t dwMediaList, - IFGAS_FontMgr* pFontMgr) { + CFGAS_FontMgr* pFontMgr) { int32_t iSheets = sheets.GetSize(); for (int32_t i = 0; i < iSheets; ++i) { IFDE_CSSStyleSheet* pSheet = sheets.GetAt(i); @@ -55,7 +55,7 @@ void CFDE_CSSRuleCollection::AddRulesFrom(const CFDE_CSSStyleSheetArray& sheets, void CFDE_CSSRuleCollection::AddRulesFrom(IFDE_CSSStyleSheet* pStyleSheet, IFDE_CSSRule* pRule, uint32_t dwMediaList, - IFGAS_FontMgr* pFontMgr) { + CFGAS_FontMgr* pFontMgr) { switch (pRule->GetType()) { case FDE_CSSRULETYPE_Style: { IFDE_CSSStyleRule* pStyleRule = static_cast(pRule); diff --git a/xfa/fde/css/fde_css.h b/xfa/fde/css/fde_css.h index 1ee037537c..b9a0d2be5d 100644 --- a/xfa/fde/css/fde_css.h +++ b/xfa/fde/css/fde_css.h @@ -10,7 +10,7 @@ #include "core/fxge/fx_dib.h" #include "xfa/fgas/crt/fgas_stream.h" #include "xfa/fgas/crt/fgas_utils.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" class CFDE_CSSAccelerator; class CFDE_CSSDeclaration; diff --git a/xfa/fde/css/fde_cssstyleselector.cpp b/xfa/fde/css/fde_cssstyleselector.cpp index 3eef4e4a4a..1bcd161f0c 100644 --- a/xfa/fde/css/fde_cssstyleselector.cpp +++ b/xfa/fde/css/fde_cssstyleselector.cpp @@ -106,7 +106,7 @@ FDE_CSSRuleData::FDE_CSSRuleData(CFDE_CSSSelector* pSel, } } -CFDE_CSSStyleSelector::CFDE_CSSStyleSelector(IFGAS_FontMgr* pFontMgr) +CFDE_CSSStyleSelector::CFDE_CSSStyleSelector(CFGAS_FontMgr* pFontMgr) : m_pFontMgr(pFontMgr), m_fDefFontSize(12.0f) { m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_High] = FDE_CSSSTYLESHEETGROUP_Author; m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_Mid] = FDE_CSSSTYLESHEETGROUP_User; diff --git a/xfa/fde/css/fde_cssstyleselector.h b/xfa/fde/css/fde_cssstyleselector.h index d72c9bf0cd..8ef3885823 100644 --- a/xfa/fde/css/fde_cssstyleselector.h +++ b/xfa/fde/css/fde_cssstyleselector.h @@ -39,7 +39,7 @@ class CFDE_CSSRuleCollection : public CFX_Target { void AddRulesFrom(const CFDE_CSSStyleSheetArray& sheets, uint32_t dwMediaList, - IFGAS_FontMgr* pFontMgr); + CFGAS_FontMgr* pFontMgr); void Clear(); int32_t CountSelectors() const { return m_iSelectors; } @@ -70,7 +70,7 @@ class CFDE_CSSRuleCollection : public CFX_Target { void AddRulesFrom(IFDE_CSSStyleSheet* pStyleSheet, IFDE_CSSRule* pRule, uint32_t dwMediaList, - IFGAS_FontMgr* pFontMgr); + CFGAS_FontMgr* pFontMgr); void AddRuleTo(CFX_MapPtrToPtr& map, uint32_t dwKey, CFDE_CSSSelector* pSel, @@ -88,7 +88,7 @@ class CFDE_CSSRuleCollection : public CFX_Target { class CFDE_CSSStyleSelector : public CFX_Target { public: - explicit CFDE_CSSStyleSelector(IFGAS_FontMgr* pFontMgr); + explicit CFDE_CSSStyleSelector(CFGAS_FontMgr* pFontMgr); ~CFDE_CSSStyleSelector() override; void SetDefFontSize(FX_FLOAT fFontSize); @@ -172,7 +172,7 @@ class CFDE_CSSStyleSelector : public CFX_Target { FDE_CSSRUBYPOSITION ToRubyPosition(FDE_CSSPROPERTYVALUE eValue); FDE_CSSRUBYSPAN ToRubySpan(FDE_CSSPROPERTYVALUE eValue); - IFGAS_FontMgr* const m_pFontMgr; + CFGAS_FontMgr* const m_pFontMgr; FX_FLOAT m_fDefFontSize; std::unique_ptr m_pRuleDataStore; CFDE_CSSStyleSheetArray m_SheetGroups[FDE_CSSSTYLESHEETGROUP_MAX]; diff --git a/xfa/fde/fde_gedevice.cpp b/xfa/fde/fde_gedevice.cpp index 314d17cdc1..4adfd54af4 100644 --- a/xfa/fde/fde_gedevice.cpp +++ b/xfa/fde/fde_gedevice.cpp @@ -14,7 +14,7 @@ #include "core/fxge/cfx_substfont.h" #include "xfa/fde/cfde_path.h" #include "xfa/fde/fde_object.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" #include "xfa/fgas/font/fgas_gefont.h" CFDE_RenderDevice::CFDE_RenderDevice(CFX_RenderDevice* pDevice, diff --git a/xfa/fde/fde_visualset.h b/xfa/fde/fde_visualset.h index 58ac4b99e4..481f4a5cbb 100644 --- a/xfa/fde/fde_visualset.h +++ b/xfa/fde/fde_visualset.h @@ -13,7 +13,7 @@ #include "xfa/fde/cfde_path.h" #include "xfa/fde/fde_object.h" #include "xfa/fgas/crt/fgas_memory.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" struct FXTEXT_CHARPOS; diff --git a/xfa/fde/ifde_txtedtengine.h b/xfa/fde/ifde_txtedtengine.h index 960edd36b7..391449ce7a 100644 --- a/xfa/fde/ifde_txtedtengine.h +++ b/xfa/fde/ifde_txtedtengine.h @@ -8,7 +8,7 @@ #define XFA_FDE_IFDE_TXTEDTENGINE_H_ #include "core/fxge/fx_dib.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" class CFDE_TxtEdtEngine; class IFDE_TxtEdtPage; diff --git a/xfa/fde/tto/fde_textout.h b/xfa/fde/tto/fde_textout.h index 3aba000db1..7e40f39dc7 100644 --- a/xfa/fde/tto/fde_textout.h +++ b/xfa/fde/tto/fde_textout.h @@ -15,7 +15,7 @@ #include "core/fxge/fx_dib.h" #include "xfa/fde/fde_object.h" #include "xfa/fgas/crt/fgas_utils.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" #define FDE_TTOSTYLE_Underline 0x0001 #define FDE_TTOSTYLE_Strikeout 0x0002 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::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::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::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 = (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 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* 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); + } 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 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) { + 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_ diff --git a/xfa/fgas/font/cfgas_fontmgr.h b/xfa/fgas/font/cfgas_fontmgr.h new file mode 100644 index 0000000000..572be382a8 --- /dev/null +++ b/xfa/fgas/font/cfgas_fontmgr.h @@ -0,0 +1,264 @@ +// Copyright 2014 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef XFA_FGAS_FONT_CFGAS_FONTMGR_H_ +#define XFA_FGAS_FONT_CFGAS_FONTMGR_H_ + +#include + +#include "core/fxcrt/fx_ext.h" +#include "core/fxge/cfx_fontmapper.h" +#include "core/fxge/fx_freetype.h" +#include "core/fxge/ifx_systemfontinfo.h" +#include "third_party/freetype/include/freetype/fttypes.h" +#include "xfa/fgas/crt/fgas_stream.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" + +#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ +#include "xfa/fgas/crt/fgas_memory.h" +#include "xfa/fgas/crt/fgas_utils.h" +#endif // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ + +#define FX_FONTSTYLE_Normal 0x00 +#define FX_FONTSTYLE_FixedPitch 0x01 +#define FX_FONTSTYLE_Serif 0x02 +#define FX_FONTSTYLE_Symbolic 0x04 +#define FX_FONTSTYLE_Script 0x08 +#define FX_FONTSTYLE_Italic 0x40 +#define FX_FONTSTYLE_Bold 0x40000 +#define FX_FONTSTYLE_BoldItalic (FX_FONTSTYLE_Bold | FX_FONTSTYLE_Italic) +#define FX_FONTSTYLE_ExactMatch 0x80000000 + +class CFX_FontSourceEnum_File; +class CFGAS_GEFont; +class CXFA_PDFFontMgr; +class CFGAS_FontMgr; + +#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ +#define FX_FONTMATCHPARA_MatchStyle 0x01 + +struct FX_FONTMATCHPARAMS { + const FX_WCHAR* pwsFamily; + uint32_t dwFontStyles; + uint32_t dwUSB; + uint32_t dwMatchFlags; + FX_WCHAR wUnicode; + uint16_t wCodePage; +}; + +typedef FX_FONTMATCHPARAMS* FX_LPFONTMATCHPARAMS; + +struct FX_FONTSIGNATURE { + uint32_t fsUsb[4]; + uint32_t fsCsb[2]; +}; + +inline bool operator==(const FX_FONTSIGNATURE& left, + const FX_FONTSIGNATURE& right) { + return left.fsUsb[0] == right.fsUsb[0] && left.fsUsb[1] == right.fsUsb[1] && + left.fsUsb[2] == right.fsUsb[2] && left.fsUsb[3] == right.fsUsb[3] && + left.fsCsb[0] == right.fsCsb[0] && left.fsCsb[1] == right.fsCsb[1]; +} + +struct FX_FONTDESCRIPTOR { + FX_WCHAR wsFontFace[32]; + uint32_t dwFontStyles; + uint8_t uCharSet; + FX_FONTSIGNATURE FontSignature; +}; + +typedef CFX_MassArrayTemplate CFX_FontDescriptors; + +inline bool operator==(const FX_FONTDESCRIPTOR& left, + const FX_FONTDESCRIPTOR& right) { + return left.uCharSet == right.uCharSet && + left.dwFontStyles == right.dwFontStyles && + left.FontSignature == right.FontSignature && + FXSYS_wcscmp(left.wsFontFace, right.wsFontFace) == 0; +} + +typedef void (*FX_LPEnumAllFonts)(CFX_FontDescriptors& fonts, + const FX_WCHAR* pwsFaceName, + FX_WCHAR wUnicode); + +FX_LPEnumAllFonts FX_GetDefFontEnumerator(); + +class CFGAS_FontMgr { + public: + explicit CFGAS_FontMgr(FX_LPEnumAllFonts pEnumerator); + ~CFGAS_FontMgr(); + + static std::unique_ptr Create(FX_LPEnumAllFonts pEnumerator); + + CFGAS_GEFont* GetDefFontByCodePage(uint16_t wCodePage, + uint32_t dwFontStyles, + const FX_WCHAR* pszFontFamily = nullptr); + CFGAS_GEFont* GetDefFontByUnicode(FX_WCHAR wUnicode, + uint32_t dwFontStyles, + const FX_WCHAR* pszFontFamily = nullptr); + CFGAS_GEFont* LoadFont(const FX_WCHAR* pszFontFamily, + uint32_t dwFontStyles, + uint16_t wCodePage = 0xFFFF); + CFGAS_GEFont* LoadFont(const uint8_t* pBuffer, int32_t iLength); + CFGAS_GEFont* LoadFont(IFX_Stream* pFontStream, + const FX_WCHAR* pszFontAlias = nullptr, + uint32_t dwFontStyles = 0, + uint16_t wCodePage = 0, + bool bSaveStream = false); + CFGAS_GEFont* LoadFont(CFGAS_GEFont* pSrcFont, + uint32_t dwFontStyles, + uint16_t wCodePage = 0xFFFF); + + // TODO(npm): This method is not being used, but probably should be in + // destructor + void ClearFontCache(); + void RemoveFont(CFGAS_GEFont* pFont); + + private: + void RemoveFont(CFX_MapPtrToPtr& fontMap, CFGAS_GEFont* pFont); + FX_FONTDESCRIPTOR const* FindFont(const FX_WCHAR* pszFontFamily, + uint32_t dwFontStyles, + uint32_t dwMatchFlags, + uint16_t wCodePage, + uint32_t dwUSB = 999, + FX_WCHAR wUnicode = 0); + + FX_LPEnumAllFonts m_pEnumerator; + CFX_FontDescriptors m_FontFaces; + CFX_ArrayTemplate m_Fonts; + CFX_MapPtrToPtr m_CPFonts; + CFX_MapPtrToPtr m_FamilyFonts; + CFX_MapPtrToPtr m_UnicodeFonts; + CFX_MapPtrToPtr m_BufferFonts; + CFX_MapPtrToPtr m_StreamFonts; + CFX_MapPtrToPtr m_DeriveFonts; +}; + +#else // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ +class CFX_FontDescriptor { + public: + CFX_FontDescriptor(); + ~CFX_FontDescriptor(); + + int32_t m_nFaceIndex; + CFX_WideString m_wsFaceName; + CFX_WideStringArray m_wsFamilyNames; + uint32_t m_dwFontStyles; + uint32_t m_dwUsb[4]; + uint32_t m_dwCsb[2]; +}; + +typedef CFX_ArrayTemplate CFX_FontDescriptors; + +struct FX_FontDescriptorInfo { + public: + CFX_FontDescriptor* pFont; + int32_t nPenalty; + + bool operator>(const FX_FontDescriptorInfo& other) const { + return nPenalty > other.nPenalty; + } + bool operator<(const FX_FontDescriptorInfo& other) const { + return nPenalty < other.nPenalty; + } + bool operator==(const FX_FontDescriptorInfo& other) const { + return nPenalty == other.nPenalty; + } +}; + +typedef CFX_ArrayTemplate CFX_FontDescriptorInfos; + +struct FX_HandleParentPath { + FX_HandleParentPath() {} + FX_HandleParentPath(const FX_HandleParentPath& x) { + pFileHandle = x.pFileHandle; + bsParentPath = x.bsParentPath; + } + FX_FileHandle* pFileHandle; + CFX_ByteString bsParentPath; +}; + +class CFX_FontSourceEnum_File { + public: + CFX_FontSourceEnum_File(); + ~CFX_FontSourceEnum_File(); + + FX_POSITION GetStartPosition(); + IFX_FileAccess* GetNext(FX_POSITION& pos); + + private: + CFX_ByteString GetNextFile(); + + CFX_WideString m_wsNext; + CFX_ObjectArray m_FolderQueue; + CFX_ByteStringArray m_FolderPaths; +}; + +class CFGAS_FontMgr { + public: + explicit CFGAS_FontMgr(CFX_FontSourceEnum_File* pFontEnum); + ~CFGAS_FontMgr(); + static std::unique_ptr Create( + CFX_FontSourceEnum_File* pFontEnum); + + CFGAS_GEFont* GetFontByCodePage(uint16_t wCodePage, + uint32_t dwFontStyles, + const FX_WCHAR* pszFontFamily); + CFGAS_GEFont* GetFontByUnicode(FX_WCHAR wUnicode, + uint32_t dwFontStyles, + const FX_WCHAR* pszFontFamily); + void ClearFontCache(); + void RemoveFont(CFGAS_GEFont* pFont); + + CFGAS_GEFont* LoadFont(const CFX_WideString& wsFaceName, + int32_t iFaceIndex, + int32_t* pFaceCount); + inline CFGAS_GEFont* LoadFont(const FX_WCHAR* pszFontFamily, + uint32_t dwFontStyles, + uint16_t wCodePage) { + return GetFontByCodePage(wCodePage, dwFontStyles, pszFontFamily); + } + bool EnumFonts(); + bool EnumFontsFromFontMapper(); + bool EnumFontsFromFiles(); + + private: + void RegisterFace(FXFT_Face pFace, const CFX_WideString* pFaceName); + void RegisterFaces(IFX_SeekableReadStream* pFontStream, + const CFX_WideString* pFaceName); + void GetNames(const uint8_t* name_table, CFX_WideStringArray& Names); + std::vector GetCharsets(FXFT_Face pFace) const; + void GetUSBCSB(FXFT_Face pFace, uint32_t* USB, uint32_t* CSB); + uint32_t GetFlags(FXFT_Face pFace); + bool VerifyUnicode(CFX_FontDescriptor* pDesc, FX_WCHAR wcUnicode); + bool VerifyUnicode(CFGAS_GEFont* pFont, FX_WCHAR wcUnicode); + int32_t IsPartName(const CFX_WideString& Name1, const CFX_WideString& Name2); + int32_t MatchFonts(CFX_FontDescriptorInfos& MatchedFonts, + uint16_t wCodePage, + uint32_t dwFontStyles, + const CFX_WideString& FontName, + FX_WCHAR wcUnicode = 0xFFFE); + int32_t CalcPenalty(CFX_FontDescriptor* pInstalled, + uint16_t wCodePage, + uint32_t dwFontStyles, + const CFX_WideString& FontName, + FX_WCHAR wcUnicode = 0xFFFE); + FXFT_Face LoadFace(IFX_SeekableReadStream* pFontStream, int32_t iFaceIndex); + IFX_SeekableReadStream* CreateFontStream(CFX_FontMapper* pFontMapper, + IFX_SystemFontInfo* pSystemFontInfo, + uint32_t index); + IFX_SeekableReadStream* CreateFontStream(const CFX_ByteString& bsFaceName); + + CFX_FontDescriptors m_InstalledFonts; + CFX_MapPtrTemplate m_Hash2CandidateList; + CFX_MapPtrTemplate*> m_Hash2Fonts; + CFX_MapPtrTemplate m_IFXFont2FileRead; + CFX_MapPtrTemplate m_FailedUnicodes2Nullptr; + CFX_FontSourceEnum_File* const m_pFontSource; +}; +#endif + +#endif // XFA_FGAS_FONT_CFGAS_FONTMGR_H_ diff --git a/xfa/fgas/font/fgas_font.h b/xfa/fgas/font/fgas_font.h deleted file mode 100644 index dbc4ec2f3b..0000000000 --- a/xfa/fgas/font/fgas_font.h +++ /dev/null @@ -1,165 +0,0 @@ -// Copyright 2014 PDFium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com - -#ifndef XFA_FGAS_FONT_FGAS_FONT_H_ -#define XFA_FGAS_FONT_FGAS_FONT_H_ - -#include "core/fxge/fx_font.h" -#include "xfa/fgas/crt/fgas_stream.h" - -#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ -#include "xfa/fgas/crt/fgas_memory.h" -#include "xfa/fgas/crt/fgas_utils.h" -#endif // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ - -class CFX_FontSourceEnum_File; -class CFGAS_GEFont; -class CXFA_PDFFontMgr; -class IFGAS_FontMgr; - -#define FX_FONTSTYLE_Normal 0x00 -#define FX_FONTSTYLE_FixedPitch 0x01 -#define FX_FONTSTYLE_Serif 0x02 -#define FX_FONTSTYLE_Symbolic 0x04 -#define FX_FONTSTYLE_Script 0x08 -#define FX_FONTSTYLE_Italic 0x40 -#define FX_FONTSTYLE_Bold 0x40000 -#define FX_FONTSTYLE_BoldItalic (FX_FONTSTYLE_Bold | FX_FONTSTYLE_Italic) -#define FX_FONTSTYLE_ExactMatch 0x80000000 - -#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ -struct FX_FONTMATCHPARAMS { - const FX_WCHAR* pwsFamily; - uint32_t dwFontStyles; - uint32_t dwUSB; - uint32_t dwMatchFlags; - FX_WCHAR wUnicode; - uint16_t wCodePage; -}; -typedef FX_FONTMATCHPARAMS* FX_LPFONTMATCHPARAMS; -typedef FX_FONTMATCHPARAMS const* FX_LPCFONTMATCHPARAMS; - -struct FX_FONTSIGNATURE { - uint32_t fsUsb[4]; - uint32_t fsCsb[2]; -}; -inline bool operator==(const FX_FONTSIGNATURE& left, - const FX_FONTSIGNATURE& right) { - return left.fsUsb[0] == right.fsUsb[0] && left.fsUsb[1] == right.fsUsb[1] && - left.fsUsb[2] == right.fsUsb[2] && left.fsUsb[3] == right.fsUsb[3] && - left.fsCsb[0] == right.fsCsb[0] && left.fsCsb[1] == right.fsCsb[1]; -} - -struct FX_FONTDESCRIPTOR { - FX_WCHAR wsFontFace[32]; - uint32_t dwFontStyles; - uint8_t uCharSet; - FX_FONTSIGNATURE FontSignature; -}; - -typedef CFX_MassArrayTemplate CFX_FontDescriptors; -inline bool operator==(const FX_FONTDESCRIPTOR& left, - const FX_FONTDESCRIPTOR& right) { - return left.uCharSet == right.uCharSet && - left.dwFontStyles == right.dwFontStyles && - left.FontSignature == right.FontSignature && - FXSYS_wcscmp(left.wsFontFace, right.wsFontFace) == 0; -} - -#define FX_FONTMATCHPARA_MacthStyle 0x01 -#define FX_FONTMATCHPARA_MacthFamily 0x02 -#define FX_FONTMATCHPARA_MacthUnicode 0x04 -typedef void (*FX_LPEnumAllFonts)(CFX_FontDescriptors& fonts, - const FX_WCHAR* pwsFaceName, - FX_WCHAR wUnicode); -FX_LPEnumAllFonts FX_GetDefFontEnumerator(); -typedef FX_FONTDESCRIPTOR const* (*FX_LPMatchFont)( - FX_LPFONTMATCHPARAMS pParams, - const CFX_FontDescriptors& fonts); -FX_LPMatchFont FX_GetDefFontMatchor(); - -class IFGAS_FontMgr { - public: - virtual ~IFGAS_FontMgr() {} - - static std::unique_ptr Create(FX_LPEnumAllFonts pEnumerator); - - virtual CFGAS_GEFont* GetDefFontByCodePage( - uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) = 0; - virtual CFGAS_GEFont* GetDefFontByCharset( - uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) = 0; - virtual CFGAS_GEFont* GetDefFontByUnicode( - FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) = 0; - virtual CFGAS_GEFont* GetDefFontByLanguage( - uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) = 0; - virtual CFGAS_GEFont* LoadFont(const FX_WCHAR* pszFontFamily, - uint32_t dwFontStyles, - uint16_t wCodePage = 0xFFFF) = 0; - virtual CFGAS_GEFont* LoadFont(const uint8_t* pBuffer, int32_t iLength) = 0; - virtual CFGAS_GEFont* LoadFont(IFX_Stream* pFontStream, - const FX_WCHAR* pszFontAlias = nullptr, - uint32_t dwFontStyles = 0, - uint16_t wCodePage = 0, - bool bSaveStream = false) = 0; - virtual CFGAS_GEFont* LoadFont(CFGAS_GEFont* pSrcFont, - uint32_t dwFontStyles, - uint16_t wCodePage = 0xFFFF) = 0; - virtual void ClearFontCache() = 0; - virtual void RemoveFont(CFGAS_GEFont* pFont) = 0; -}; - -#else // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ - -class IFGAS_FontMgr { - public: - virtual ~IFGAS_FontMgr() {} - - static std::unique_ptr Create( - CFX_FontSourceEnum_File* pFontEnum); - - virtual CFGAS_GEFont* GetDefFontByCodePage(uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - virtual CFGAS_GEFont* GetDefFontByCharset(uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - virtual CFGAS_GEFont* GetDefFontByUnicode(FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - virtual CFGAS_GEFont* GetDefFontByLanguage(uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - virtual CFGAS_GEFont* GetFontByCodePage(uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - inline CFGAS_GEFont* LoadFont(const FX_WCHAR* pszFontFamily, - uint32_t dwFontStyles, - uint16_t wCodePage) { - return GetFontByCodePage(wCodePage, dwFontStyles, pszFontFamily); - } - virtual CFGAS_GEFont* GetFontByCharset(uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - virtual CFGAS_GEFont* GetFontByUnicode(FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - virtual CFGAS_GEFont* GetFontByLanguage(uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) = 0; - virtual void ClearFontCache() = 0; - virtual void RemoveFont(CFGAS_GEFont* pFont) = 0; -}; -#endif // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ - -#endif // XFA_FGAS_FONT_FGAS_FONT_H_ diff --git a/xfa/fgas/font/fgas_fontutils.cpp b/xfa/fgas/font/fgas_fontutils.cpp index 8e923c1209..e74056b53e 100644 --- a/xfa/fgas/font/fgas_fontutils.cpp +++ b/xfa/fgas/font/fgas_fontutils.cpp @@ -7,7 +7,7 @@ #include "xfa/fgas/font/fgas_fontutils.h" #include "core/fxcrt/fx_ext.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" uint32_t FGAS_GetFontHashCode(uint16_t wCodePage, uint32_t dwFontStyles) { uint32_t dwHash = wCodePage; diff --git a/xfa/fgas/font/fgas_gefont.cpp b/xfa/fgas/font/fgas_gefont.cpp index b78cfe516a..8a6ff28b43 100644 --- a/xfa/fgas/font/fgas_gefont.cpp +++ b/xfa/fgas/font/fgas_gefont.cpp @@ -20,7 +20,7 @@ CFGAS_GEFont* CFGAS_GEFont::LoadFont(const FX_WCHAR* pszFontFamily, uint32_t dwFontStyles, uint16_t wCodePage, - IFGAS_FontMgr* pFontMgr) { + CFGAS_FontMgr* pFontMgr) { #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_ if (pFontMgr) return pFontMgr->GetFontByCodePage(wCodePage, dwFontStyles, pszFontFamily); @@ -37,7 +37,7 @@ CFGAS_GEFont* CFGAS_GEFont::LoadFont(const FX_WCHAR* pszFontFamily, // static CFGAS_GEFont* CFGAS_GEFont::LoadFont(CFX_Font* pExternalFont, - IFGAS_FontMgr* pFontMgr) { + CFGAS_FontMgr* pFontMgr) { CFGAS_GEFont* pFont = new CFGAS_GEFont(pFontMgr); if (!pFont->LoadFontInternal(pExternalFont)) { pFont->Release(); @@ -48,7 +48,7 @@ CFGAS_GEFont* CFGAS_GEFont::LoadFont(CFX_Font* pExternalFont, // static CFGAS_GEFont* CFGAS_GEFont::LoadFont(std::unique_ptr pInternalFont, - IFGAS_FontMgr* pFontMgr) { + CFGAS_FontMgr* pFontMgr) { CFGAS_GEFont* pFont = new CFGAS_GEFont(pFontMgr); if (!pFont->LoadFontInternal(std::move(pInternalFont))) { pFont->Release(); @@ -61,7 +61,7 @@ CFGAS_GEFont* CFGAS_GEFont::LoadFont(std::unique_ptr pInternalFont, // static CFGAS_GEFont* CFGAS_GEFont::LoadFont(const uint8_t* pBuffer, int32_t iLength, - IFGAS_FontMgr* pFontMgr) { + CFGAS_FontMgr* pFontMgr) { CFGAS_GEFont* pFont = new CFGAS_GEFont(pFontMgr); if (!pFont->LoadFontInternal(pBuffer, iLength)) { pFont->Release(); @@ -72,7 +72,7 @@ CFGAS_GEFont* CFGAS_GEFont::LoadFont(const uint8_t* pBuffer, // static CFGAS_GEFont* CFGAS_GEFont::LoadFont(IFX_Stream* pFontStream, - IFGAS_FontMgr* pFontMgr, + CFGAS_FontMgr* pFontMgr, bool bSaveStream) { CFGAS_GEFont* pFont = new CFGAS_GEFont(pFontMgr); if (!pFont->LoadFontInternal(pFontStream, bSaveStream)) { @@ -83,7 +83,7 @@ CFGAS_GEFont* CFGAS_GEFont::LoadFont(IFX_Stream* pFontStream, } #endif // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ -CFGAS_GEFont::CFGAS_GEFont(IFGAS_FontMgr* pFontMgr) +CFGAS_GEFont::CFGAS_GEFont(CFGAS_FontMgr* pFontMgr) : #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_ m_bUseLogFontStyle(false), diff --git a/xfa/fgas/font/fgas_gefont.h b/xfa/fgas/font/fgas_gefont.h index 4ce61f3989..7baafefc7e 100644 --- a/xfa/fgas/font/fgas_gefont.h +++ b/xfa/fgas/font/fgas_gefont.h @@ -11,7 +11,7 @@ #include "core/fxcrt/fx_memory.h" #include "xfa/fgas/crt/fgas_utils.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" #define FXFONT_SUBST_ITALIC 0x02 @@ -23,17 +23,17 @@ class CFGAS_GEFont { static CFGAS_GEFont* LoadFont(const FX_WCHAR* pszFontFamily, uint32_t dwFontStyles, uint16_t wCodePage, - IFGAS_FontMgr* pFontMgr); + CFGAS_FontMgr* pFontMgr); static CFGAS_GEFont* LoadFont(CFX_Font* pExternalFont, - IFGAS_FontMgr* pFontMgr); + CFGAS_FontMgr* pFontMgr); static CFGAS_GEFont* LoadFont(std::unique_ptr pInternalFont, - IFGAS_FontMgr* pFontMgr); + CFGAS_FontMgr* pFontMgr); #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ static CFGAS_GEFont* LoadFont(const uint8_t* pBuffer, int32_t iLength, - IFGAS_FontMgr* pFontMgr); + CFGAS_FontMgr* pFontMgr); static CFGAS_GEFont* LoadFont(IFX_Stream* pFontStream, - IFGAS_FontMgr* pFontMgr, + CFGAS_FontMgr* pFontMgr, bool bSaveStream); #endif @@ -63,7 +63,7 @@ class CFGAS_GEFont { #endif protected: - explicit CFGAS_GEFont(IFGAS_FontMgr* pFontMgr); + explicit CFGAS_GEFont(CFGAS_FontMgr* pFontMgr); CFGAS_GEFont(CFGAS_GEFont* src, uint32_t dwFontStyles); #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ @@ -95,7 +95,7 @@ class CFGAS_GEFont { #endif CFX_Font* m_pFont; CFGAS_GEFont* const m_pSrcFont; - IFGAS_FontMgr* const m_pFontMgr; + CFGAS_FontMgr* const m_pFontMgr; int32_t m_iRefCount; bool m_bExternalFont; std::unique_ptr> m_pStream; diff --git a/xfa/fgas/font/fgas_stdfontmgr.cpp b/xfa/fgas/font/fgas_stdfontmgr.cpp deleted file mode 100644 index d4907bb919..0000000000 --- a/xfa/fgas/font/fgas_stdfontmgr.cpp +++ /dev/null @@ -1,1384 +0,0 @@ -// 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/fgas_stdfontmgr.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 "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_ - -std::unique_ptr IFGAS_FontMgr::Create( - FX_LPEnumAllFonts pEnumerator) { - return std::unique_ptr(new CFGAS_StdFontMgrImp(pEnumerator)); -} - -CFGAS_StdFontMgrImp::CFGAS_StdFontMgrImp(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_StdFontMgrImp::~CFGAS_StdFontMgrImp() { - 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_StdFontMgrImp::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_StdFontMgrImp::GetDefFontByCharset( - uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return GetDefFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles, - pszFontFamily); -} - -CFGAS_GEFont* CFGAS_StdFontMgrImp::GetDefFontByUnicode( - FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - const FGAS_FONTUSB* pRet = FGAS_GetUnicodeBitField(wUnicode); - if (pRet->wBitField == 999) - return nullptr; - - uint32_t dwHash = - FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, pRet->wBitField); - 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_StdFontMgrImp::GetDefFontByLanguage( - uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return GetDefFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage), - dwFontStyles, pszFontFamily); -} - -CFGAS_GEFont* CFGAS_StdFontMgrImp::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_StdFontMgrImp::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_StdFontMgrImp::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_StdFontMgrImp::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_StdFontMgrImp::ClearFontCache() { - for (int32_t i = 0; i < m_Fonts.GetSize(); i++) - m_Fonts[i]->Reset(); -} - -void CFGAS_StdFontMgrImp::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_StdFontMgrImp::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_StdFontMgrImp::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 = FX_DefFontMatcher(¶ms, m_FontFaces); - if (pDesc) { - return pDesc; - } - if (pszFontFamily && m_pEnumerator) { - CFX_FontDescriptors namedFonts(100); - m_pEnumerator(namedFonts, pszFontFamily, wUnicode); - params.pwsFamily = nullptr; - pDesc = FX_DefFontMatcher(¶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; -} - -FX_FONTDESCRIPTOR const* FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams, - const CFX_FontDescriptors& fonts) { - FX_FONTDESCRIPTOR const* pBestFont = nullptr; - int32_t iBestSimilar = 0; - bool bMatchStyle = (pParams->dwMatchFlags & FX_FONTMATCHPARA_MacthStyle) > 0; - int32_t iCount = fonts.GetSize(); - for (int32_t i = 0; i < iCount; ++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 = FX_GetSimilarValue(pFont, pParams->dwFontStyles); - if (iBestSimilar < iSimilarValue) { - iBestSimilar = iSimilarValue; - pBestFont = pFont; - } - } - return iBestSimilar < 1 ? nullptr : pBestFont; -} - -int32_t FX_GetSimilarValue(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_LPMatchFont FX_GetDefFontMatchor() { - return FX_DefFontMatcher; -} - -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 -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 -}; - -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 IFGAS_FontMgr::Create( - CFX_FontSourceEnum_File* pFontEnum) { - if (!pFontEnum) - return nullptr; - - std::unique_ptr pFontMgr(new CFGAS_FontMgrImp(pFontEnum)); - if (!pFontMgr->EnumFonts()) - return nullptr; - return std::move(pFontMgr); -} - -CFGAS_FontMgrImp::CFGAS_FontMgrImp(CFX_FontSourceEnum_File* pFontEnum) - : m_pFontSource(pFontEnum) {} - -CFGAS_FontMgrImp::~CFGAS_FontMgrImp() { - 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_FontMgrImp::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_FontMgrImp::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_FontMgrImp::EnumFonts() { - if (EnumFontsFromFontMapper()) - return true; - return EnumFontsFromFiles(); -} - -CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByCodePage( - uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return nullptr; -} - -CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByCharset( - uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return nullptr; -} - -CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByUnicode( - FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return nullptr; -} - -CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByLanguage( - uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return nullptr; -} - -CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByCodePage( - uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - CFX_ByteString bsHash; - bsHash.Format("%d, %d", wCodePage, dwFontStyles); - bsHash += CFX_WideString(pszFontFamily).UTF8Encode(); - uint32_t dwHash = FX_HashCode_GetA(bsHash.AsStringC(), false); - CFX_ArrayTemplate* 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_FontMgrImp::GetFontByCharset( - uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return GetFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles, - pszFontFamily); -} - -CFGAS_GEFont* CFGAS_FontMgrImp::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_FontMgrImp::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_FontMgrImp::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_FontMgrImp::GetFontByLanguage( - uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) { - return GetFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage), dwFontStyles, - pszFontFamily); -} - -CFGAS_GEFont* CFGAS_FontMgrImp::LoadFont(const CFX_WideString& wsFaceName, - int32_t iFaceIndex, - int32_t* pFaceCount) { - CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr(); - CFX_FontMapper* pFontMapper = pFontMgr->GetBuiltinMapper(); - if (!pFontMapper) - return nullptr; - - IFX_SystemFontInfo* pSystemFontInfo = pFontMapper->GetSystemFontInfo(); - if (!pSystemFontInfo) - return nullptr; - - IFX_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_FontMgrImp::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_FontMgrImp::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_FontMgrImp::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_FontMgrImp::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(); -} - -struct FX_BitCodePage { - uint16_t wBit; - uint16_t wCodePage; -}; -static 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; -} - -int32_t CFGAS_FontMgrImp::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_FontMgrImp::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_FontMgrImp::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_FontMgrImp::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_FontMgrImp::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_FontMgrImp::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; -} - -#define GetUInt8(p) ((uint8_t)((p)[0])) -#define GetUInt16(p) ((uint16_t)((p)[0] << 8 | (p)[1])) -#define GetUInt32(p) \ - ((uint32_t)((p)[0] << 24 | (p)[1] << 16 | (p)[2] << 8 | (p)[3])) - -void CFGAS_FontMgrImp::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); - } - } -} -#undef GetUInt8 -#undef GetUInt16 -#undef GetUInt32 -struct FX_BIT2CHARSET { - uint16_t wBit; - uint16_t wCharset; -}; - -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}, -}; - -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}, -}; - -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}, -}; - -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}, -}; - -#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 CFGAS_FontMgrImp::GetCharsets(FXFT_Face pFace) const { - std::vector 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_FontMgrImp::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_FontMgrImp::IsPartName(const CFX_WideString& Name1, - const CFX_WideString& Name2) { - if (Name1.Find(Name2.c_str()) != -1) { - return 1; - } - return 0; -} - -#endif diff --git a/xfa/fgas/font/fgas_stdfontmgr.h b/xfa/fgas/font/fgas_stdfontmgr.h deleted file mode 100644 index 2c7a1a2fdd..0000000000 --- a/xfa/fgas/font/fgas_stdfontmgr.h +++ /dev/null @@ -1,222 +0,0 @@ -// Copyright 2014 PDFium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com - -#ifndef XFA_FGAS_FONT_FGAS_STDFONTMGR_H_ -#define XFA_FGAS_FONT_FGAS_STDFONTMGR_H_ - -#include - -#include "core/fxcrt/fx_ext.h" -#include "core/fxge/cfx_fontmapper.h" -#include "core/fxge/fx_freetype.h" -#include "core/fxge/ifx_systemfontinfo.h" -#include "third_party/freetype/include/freetype/fttypes.h" -#include "xfa/fgas/font/fgas_font.h" - -#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ -int32_t FX_GetSimilarValue(FX_FONTDESCRIPTOR const* pFont, - uint32_t dwFontStyles); -FX_FONTDESCRIPTOR const* FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams, - const CFX_FontDescriptors& fonts); - -class CFGAS_StdFontMgrImp : public IFGAS_FontMgr { - public: - explicit CFGAS_StdFontMgrImp(FX_LPEnumAllFonts pEnumerator); - ~CFGAS_StdFontMgrImp() override; - - // IFGAS_FontMgr: - CFGAS_GEFont* GetDefFontByCodePage( - uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) override; - CFGAS_GEFont* GetDefFontByCharset( - uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) override; - CFGAS_GEFont* GetDefFontByUnicode( - FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) override; - CFGAS_GEFont* GetDefFontByLanguage( - uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily = nullptr) override; - CFGAS_GEFont* LoadFont(const FX_WCHAR* pszFontFamily, - uint32_t dwFontStyles, - uint16_t wCodePage = 0xFFFF) override; - CFGAS_GEFont* LoadFont(const uint8_t* pBuffer, int32_t iLength) override; - CFGAS_GEFont* LoadFont(IFX_Stream* pFontStream, - const FX_WCHAR* pszFontAlias = nullptr, - uint32_t dwFontStyles = 0, - uint16_t wCodePage = 0, - bool bSaveStream = false) override; - CFGAS_GEFont* LoadFont(CFGAS_GEFont* pSrcFont, - uint32_t dwFontStyles, - uint16_t wCodePage = 0xFFFF) override; - - void ClearFontCache() override; - void RemoveFont(CFGAS_GEFont* pFont) override; - - protected: - void RemoveFont(CFX_MapPtrToPtr& fontMap, CFGAS_GEFont* pFont); - FX_FONTDESCRIPTOR const* FindFont(const FX_WCHAR* pszFontFamily, - uint32_t dwFontStyles, - uint32_t dwMatchFlags, - uint16_t wCodePage, - uint32_t dwUSB = 999, - FX_WCHAR wUnicode = 0); - - FX_LPEnumAllFonts m_pEnumerator; - CFX_FontDescriptors m_FontFaces; - CFX_ArrayTemplate m_Fonts; - CFX_MapPtrToPtr m_CPFonts; - CFX_MapPtrToPtr m_FamilyFonts; - CFX_MapPtrToPtr m_UnicodeFonts; - CFX_MapPtrToPtr m_BufferFonts; - CFX_MapPtrToPtr m_StreamFonts; - CFX_MapPtrToPtr m_DeriveFonts; -}; -uint32_t FX_GetGdiFontStyles(const LOGFONTW& lf); - -#else - -class CFX_FontDescriptor { - public: - CFX_FontDescriptor(); - ~CFX_FontDescriptor(); - - int32_t m_nFaceIndex; - CFX_WideString m_wsFaceName; - CFX_WideStringArray m_wsFamilyNames; - uint32_t m_dwFontStyles; - uint32_t m_dwUsb[4]; - uint32_t m_dwCsb[2]; -}; - -typedef CFX_ArrayTemplate CFX_FontDescriptors; - -struct FX_FontDescriptorInfo { - public: - CFX_FontDescriptor* pFont; - int32_t nPenalty; - - bool operator>(const FX_FontDescriptorInfo& other) const { - return nPenalty > other.nPenalty; - } - bool operator<(const FX_FontDescriptorInfo& other) const { - return nPenalty < other.nPenalty; - } - bool operator==(const FX_FontDescriptorInfo& other) const { - return nPenalty == other.nPenalty; - } -}; - -typedef CFX_ArrayTemplate CFX_FontDescriptorInfos; - -struct FX_HandleParentPath { - FX_HandleParentPath() {} - FX_HandleParentPath(const FX_HandleParentPath& x) { - pFileHandle = x.pFileHandle; - bsParentPath = x.bsParentPath; - } - FX_FileHandle* pFileHandle; - CFX_ByteString bsParentPath; -}; - -class CFX_FontSourceEnum_File { - public: - CFX_FontSourceEnum_File(); - ~CFX_FontSourceEnum_File(); - - FX_POSITION GetStartPosition(); - IFX_FileAccess* GetNext(FX_POSITION& pos); - - private: - CFX_ByteString GetNextFile(); - - CFX_WideString m_wsNext; - CFX_ObjectArray m_FolderQueue; - CFX_ByteStringArray m_FolderPaths; -}; - -class CFGAS_FontMgrImp : public IFGAS_FontMgr { - public: - explicit CFGAS_FontMgrImp(CFX_FontSourceEnum_File* pFontEnum); - ~CFGAS_FontMgrImp() override; - - // IFGAS_FontMgr: - CFGAS_GEFont* GetDefFontByCodePage(uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - CFGAS_GEFont* GetDefFontByCharset(uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - CFGAS_GEFont* GetDefFontByUnicode(FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - CFGAS_GEFont* GetDefFontByLanguage(uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - CFGAS_GEFont* GetFontByCodePage(uint16_t wCodePage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - CFGAS_GEFont* GetFontByCharset(uint8_t nCharset, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - CFGAS_GEFont* GetFontByUnicode(FX_WCHAR wUnicode, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - CFGAS_GEFont* GetFontByLanguage(uint16_t wLanguage, - uint32_t dwFontStyles, - const FX_WCHAR* pszFontFamily) override; - void ClearFontCache() override; - void RemoveFont(CFGAS_GEFont* pFont) override; - - CFGAS_GEFont* LoadFont(const CFX_WideString& wsFaceName, - int32_t iFaceIndex, - int32_t* pFaceCount); - bool EnumFonts(); - bool EnumFontsFromFontMapper(); - bool EnumFontsFromFiles(); - - protected: - void RegisterFace(FXFT_Face pFace, - const CFX_WideString* pFaceName); - void RegisterFaces(IFX_SeekableReadStream* pFontStream, - const CFX_WideString* pFaceName); - void GetNames(const uint8_t* name_table, CFX_WideStringArray& Names); - std::vector GetCharsets(FXFT_Face pFace) const; - void GetUSBCSB(FXFT_Face pFace, uint32_t* USB, uint32_t* CSB); - uint32_t GetFlags(FXFT_Face pFace); - bool VerifyUnicode(CFX_FontDescriptor* pDesc, FX_WCHAR wcUnicode); - bool VerifyUnicode(CFGAS_GEFont* pFont, FX_WCHAR wcUnicode); - int32_t IsPartName(const CFX_WideString& Name1, const CFX_WideString& Name2); - int32_t MatchFonts(CFX_FontDescriptorInfos& MatchedFonts, - uint16_t wCodePage, - uint32_t dwFontStyles, - const CFX_WideString& FontName, - FX_WCHAR wcUnicode = 0xFFFE); - int32_t CalcPenalty(CFX_FontDescriptor* pInstalled, - uint16_t wCodePage, - uint32_t dwFontStyles, - const CFX_WideString& FontName, - FX_WCHAR wcUnicode = 0xFFFE); - FXFT_Face LoadFace(IFX_SeekableReadStream* pFontStream, int32_t iFaceIndex); - IFX_SeekableReadStream* CreateFontStream(CFX_FontMapper* pFontMapper, - IFX_SystemFontInfo* pSystemFontInfo, - uint32_t index); - IFX_SeekableReadStream* CreateFontStream(const CFX_ByteString& bsFaceName); - - CFX_FontDescriptors m_InstalledFonts; - CFX_MapPtrTemplate m_Hash2CandidateList; - CFX_MapPtrTemplate*> m_Hash2Fonts; - CFX_MapPtrTemplate m_IFXFont2FileRead; - CFX_MapPtrTemplate m_FailedUnicodes2Nullptr; - CFX_FontSourceEnum_File* const m_pFontSource; -}; -#endif - -#endif // XFA_FGAS_FONT_FGAS_STDFONTMGR_H_ diff --git a/xfa/fgas/layout/fgas_unicode.h b/xfa/fgas/layout/fgas_unicode.h index 12614a1299..f7a0d201d9 100644 --- a/xfa/fgas/layout/fgas_unicode.h +++ b/xfa/fgas/layout/fgas_unicode.h @@ -8,7 +8,7 @@ #define XFA_FGAS_LAYOUT_FGAS_UNICODE_H_ #include "xfa/fgas/crt/fgas_utils.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" struct FX_TPO { int32_t index; diff --git a/xfa/fwl/theme/cfwl_widgettp.cpp b/xfa/fwl/theme/cfwl_widgettp.cpp index bbcbabbb54..80a7b8fe4a 100644 --- a/xfa/fwl/theme/cfwl_widgettp.cpp +++ b/xfa/fwl/theme/cfwl_widgettp.cpp @@ -10,7 +10,7 @@ #include "xfa/fde/tto/fde_textout.h" #include "xfa/fgas/font/fgas_gefont.h" -#include "xfa/fgas/font/fgas_stdfontmgr.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" #include "xfa/fwl/core/cfwl_themebackground.h" #include "xfa/fwl/core/cfwl_themepart.h" #include "xfa/fwl/core/cfwl_themetext.h" @@ -664,10 +664,10 @@ bool CFWL_FontData::LoadFont(const CFX_WideStringC& wsFontFamily, m_dwCodePage = dwCodePage; if (!m_pFontMgr) { #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ - m_pFontMgr = IFGAS_FontMgr::Create(FX_GetDefFontEnumerator()); + m_pFontMgr = CFGAS_FontMgr::Create(FX_GetDefFontEnumerator()); #else m_pFontSource.reset(new CFX_FontSourceEnum_File); - m_pFontMgr = IFGAS_FontMgr::Create(m_pFontSource.get()); + m_pFontMgr = CFGAS_FontMgr::Create(m_pFontSource.get()); #endif } m_pFont.reset(CFGAS_GEFont::LoadFont(wsFontFamily.c_str(), dwFontStyles, diff --git a/xfa/fwl/theme/cfwl_widgettp.h b/xfa/fwl/theme/cfwl_widgettp.h index 73625d05d8..4a9ef1347b 100644 --- a/xfa/fwl/theme/cfwl_widgettp.h +++ b/xfa/fwl/theme/cfwl_widgettp.h @@ -96,7 +96,7 @@ class CFGAS_GEFont; class CFWL_ThemeBackground; class CFWL_ThemePart; class CFWL_ThemeText; -class IFGAS_FontMgr; +class CFGAS_FontMgr; class IFWL_Widget; #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_ @@ -245,7 +245,7 @@ class CFWL_FontData { #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_ std::unique_ptr m_pFontSource; #endif - std::unique_ptr m_pFontMgr; + std::unique_ptr m_pFontMgr; std::unique_ptr m_pFont; }; diff --git a/xfa/fxfa/app/xfa_ffapp.cpp b/xfa/fxfa/app/xfa_ffapp.cpp index c5dcad848c..bfb9822ecc 100644 --- a/xfa/fxfa/app/xfa_ffapp.cpp +++ b/xfa/fxfa/app/xfa_ffapp.cpp @@ -9,7 +9,7 @@ #include #include -#include "xfa/fgas/font/fgas_stdfontmgr.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" #include "xfa/fwl/core/cfwl_widgetmgr.h" #include "xfa/fwl/core/fwl_noteimp.h" #include "xfa/fxfa/app/xfa_fwladapter.h" @@ -115,13 +115,13 @@ CXFA_FontMgr* CXFA_FFApp::GetXFAFontMgr() const { return m_pFontMgr.get(); } -IFGAS_FontMgr* CXFA_FFApp::GetFDEFontMgr() { +CFGAS_FontMgr* CXFA_FFApp::GetFDEFontMgr() { if (!m_pFDEFontMgr) { #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ - m_pFDEFontMgr = IFGAS_FontMgr::Create(FX_GetDefFontEnumerator()); + m_pFDEFontMgr = CFGAS_FontMgr::Create(FX_GetDefFontEnumerator()); #else m_pFontSource.reset(new CFX_FontSourceEnum_File); - m_pFDEFontMgr = IFGAS_FontMgr::Create(m_pFontSource.get()); + m_pFDEFontMgr = CFGAS_FontMgr::Create(m_pFontSource.get()); #endif } return m_pFDEFontMgr.get(); diff --git a/xfa/fxfa/app/xfa_fontmgr.cpp b/xfa/fxfa/app/xfa_fontmgr.cpp index 589dcd42f2..ddac27d533 100644 --- a/xfa/fxfa/app/xfa_fontmgr.cpp +++ b/xfa/fxfa/app/xfa_fontmgr.cpp @@ -1749,7 +1749,7 @@ CFGAS_GEFont* CXFA_DefFontMgr::GetFont(CXFA_FFDoc* hDoc, uint32_t dwFontStyles, uint16_t wCodePage) { CFX_WideString wsFontName(wsFontFamily); - IFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr(); + CFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr(); CFGAS_GEFont* pFont = pFDEFontMgr->LoadFont(wsFontName.c_str(), dwFontStyles, wCodePage); if (!pFont) { @@ -1793,7 +1793,7 @@ CFGAS_GEFont* CXFA_DefFontMgr::GetDefaultFont( const CFX_WideStringC& wsFontFamily, uint32_t dwFontStyles, uint16_t wCodePage) { - IFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr(); + CFGAS_FontMgr* pFDEFontMgr = hDoc->GetApp()->GetFDEFontMgr(); CFGAS_GEFont* pFont = pFDEFontMgr->LoadFont(L"Arial Narrow", dwFontStyles, wCodePage); if (!pFont) { @@ -1836,7 +1836,7 @@ CFGAS_GEFont* CXFA_PDFFontMgr::FindFont(const CFX_ByteString& strPsName, } CFX_ByteString name = strPsName; name.Remove(' '); - IFGAS_FontMgr* pFDEFontMgr = m_pDoc->GetApp()->GetFDEFontMgr(); + CFGAS_FontMgr* pFDEFontMgr = m_pDoc->GetApp()->GetFDEFontMgr(); for (const auto& it : *pFontSetDict) { const CFX_ByteString& key = it.first; CPDF_Object* pObj = it.second; diff --git a/xfa/fxfa/app/xfa_textlayout.cpp b/xfa/fxfa/app/xfa_textlayout.cpp index 291cc5133a..345fc272e3 100644 --- a/xfa/fxfa/app/xfa_textlayout.cpp +++ b/xfa/fxfa/app/xfa_textlayout.cpp @@ -94,7 +94,7 @@ void CXFA_TextParser::InitCSSData(CXFA_TextProvider* pTextProvider) { if (!m_pSelector) { CXFA_FFDoc* pDoc = pTextProvider->GetDocNode(); - IFGAS_FontMgr* pFontMgr = pDoc->GetApp()->GetFDEFontMgr(); + CFGAS_FontMgr* pFontMgr = pDoc->GetApp()->GetFDEFontMgr(); ASSERT(pFontMgr); m_pSelector.reset(new CFDE_CSSStyleSelector(pFontMgr)); FX_FLOAT fFontSize = 10; diff --git a/xfa/fxfa/xfa_ffapp.h b/xfa/fxfa/xfa_ffapp.h index 359f8ffa3c..e7475de889 100644 --- a/xfa/fxfa/xfa_ffapp.h +++ b/xfa/fxfa/xfa_ffapp.h @@ -12,7 +12,7 @@ #include "core/fpdfapi/parser/cpdf_stream.h" #include "core/fpdfapi/parser/cpdf_stream_acc.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" #include "xfa/fwl/core/ifwl_app.h" #include "xfa/fxfa/fxfa.h" @@ -52,7 +52,7 @@ class CXFA_FFApp { CXFA_FFDocHandler* GetDocHandler(); CXFA_FWLAdapterWidgetMgr* GetWidgetMgr(CFWL_WidgetMgrDelegate* pDelegate); - IFGAS_FontMgr* GetFDEFontMgr(); + CFGAS_FontMgr* GetFDEFontMgr(); CXFA_FWLTheme* GetFWLTheme(); IXFA_AppProvider* GetAppProvider() const { return m_pProvider; } @@ -79,7 +79,7 @@ class CXFA_FFApp { // // TODO(dsinclair): The GEFont should have the FontMgr as the pointer instead // of the DEFFontMgr so this goes away. Bug 561. - std::unique_ptr m_pFDEFontMgr; + std::unique_ptr m_pFDEFontMgr; std::unique_ptr m_pFontMgr; #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_ diff --git a/xfa/fxfa/xfa_fontmgr.h b/xfa/fxfa/xfa_fontmgr.h index 8838bbcd0c..a6a5822e0d 100644 --- a/xfa/fxfa/xfa_fontmgr.h +++ b/xfa/fxfa/xfa_fontmgr.h @@ -12,7 +12,7 @@ #include "core/fxcrt/fx_ext.h" #include "core/fxcrt/fx_system.h" -#include "xfa/fgas/font/fgas_font.h" +#include "xfa/fgas/font/cfgas_fontmgr.h" #include "xfa/fxfa/fxfa.h" class CPDF_Font; -- cgit v1.2.3