summaryrefslogtreecommitdiff
path: root/core/fxge/android/fpf_skiafontmgr.cpp
diff options
context:
space:
mode:
authorDan Sinclair <dsinclair@chromium.org>2016-03-14 13:35:12 -0400
committerDan Sinclair <dsinclair@chromium.org>2016-03-14 13:35:12 -0400
commit764ec513eecbebd12781bcc96ce81ed5e736ee92 (patch)
tree12763fde4be1f10ea1183d92185917b2b587e00b /core/fxge/android/fpf_skiafontmgr.cpp
parent97da97662417085774f75c26e535c6fbe70266ae (diff)
downloadpdfium-764ec513eecbebd12781bcc96ce81ed5e736ee92.tar.xz
Move core/src/ up to core/.
This CL moves the core/src/ files up to core/ and fixes up the include guards, includes and build files. R=tsepez@chromium.org Review URL: https://codereview.chromium.org/1800523005 .
Diffstat (limited to 'core/fxge/android/fpf_skiafontmgr.cpp')
-rw-r--r--core/fxge/android/fpf_skiafontmgr.cpp524
1 files changed, 524 insertions, 0 deletions
diff --git a/core/fxge/android/fpf_skiafontmgr.cpp b/core/fxge/android/fpf_skiafontmgr.cpp
new file mode 100644
index 0000000000..e9249ba76f
--- /dev/null
+++ b/core/fxge/android/fpf_skiafontmgr.cpp
@@ -0,0 +1,524 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "core/include/fxcrt/fx_system.h"
+
+#if _FX_OS_ == _FX_ANDROID_
+
+#define FPF_SKIAMATCHWEIGHT_NAME1 62
+#define FPF_SKIAMATCHWEIGHT_NAME2 60
+#define FPF_SKIAMATCHWEIGHT_1 16
+#define FPF_SKIAMATCHWEIGHT_2 8
+
+#include "core/fxge/android/fpf_skiafont.h"
+#include "core/fxge/android/fpf_skiafontmgr.h"
+#include "core/include/fxcrt/fx_ext.h"
+#include "core/include/fxge/fx_freetype.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static unsigned long FPF_SkiaStream_Read(FXFT_Stream stream,
+ unsigned long offset,
+ unsigned char* buffer,
+ unsigned long count) {
+ IFX_FileRead* pFileRead = (IFX_FileRead*)stream->descriptor.pointer;
+ if (!pFileRead) {
+ return 0;
+ }
+ if (count > 0) {
+ if (pFileRead->ReadBlock(buffer, (FX_FILESIZE)offset, (size_t)count) !=
+ count) {
+ return 0;
+ }
+ }
+ return count;
+}
+static void FPF_SkiaStream_Close(FXFT_Stream stream) {}
+#ifdef __cplusplus
+};
+#endif
+struct FPF_SKIAFONTMAP {
+ FX_DWORD dwFamily;
+ FX_DWORD dwSubSt;
+};
+static const FPF_SKIAFONTMAP g_SkiaFontmap[] = {
+ {0x58c5083, 0xc8d2e345}, {0x5dfade2, 0xe1633081},
+ {0x684317d, 0xe1633081}, {0x14ee2d13, 0xc8d2e345},
+ {0x3918fe2d, 0xbbeeec72}, {0x3b98b31c, 0xe1633081},
+ {0x3d49f40e, 0xe1633081}, {0x432c41c5, 0xe1633081},
+ {0x491b6ad0, 0xe1633081}, {0x5612cab1, 0x59b9f8f1},
+ {0x779ce19d, 0xc8d2e345}, {0x7cc9510b, 0x59b9f8f1},
+ {0x83746053, 0xbbeeec72}, {0xaaa60c03, 0xbbeeec72},
+ {0xbf85ff26, 0xe1633081}, {0xc04fe601, 0xbbeeec72},
+ {0xca3812d5, 0x59b9f8f1}, {0xca383e15, 0x59b9f8f1},
+ {0xcad5eaf6, 0x59b9f8f1}, {0xcb7a04c8, 0xc8d2e345},
+ {0xfb4ce0de, 0xe1633081},
+};
+FX_DWORD FPF_SkiaGetSubstFont(FX_DWORD dwHash) {
+ int32_t iStart = 0;
+ int32_t iEnd = sizeof(g_SkiaFontmap) / sizeof(FPF_SKIAFONTMAP);
+ while (iStart <= iEnd) {
+ int32_t iMid = (iStart + iEnd) / 2;
+ const FPF_SKIAFONTMAP* pItem = &g_SkiaFontmap[iMid];
+ if (dwHash < pItem->dwFamily) {
+ iEnd = iMid - 1;
+ } else if (dwHash > pItem->dwFamily) {
+ iStart = iMid + 1;
+ } else {
+ return pItem->dwSubSt;
+ }
+ }
+ return 0;
+}
+static const FPF_SKIAFONTMAP g_SkiaSansFontMap[] = {
+ {0x58c5083, 0xd5b8d10f}, {0x14ee2d13, 0xd5b8d10f},
+ {0x779ce19d, 0xd5b8d10f}, {0xcb7a04c8, 0xd5b8d10f},
+ {0xfb4ce0de, 0xd5b8d10f},
+};
+FX_DWORD FPF_SkiaGetSansFont(FX_DWORD dwHash) {
+ int32_t iStart = 0;
+ int32_t iEnd = sizeof(g_SkiaSansFontMap) / sizeof(FPF_SKIAFONTMAP);
+ while (iStart <= iEnd) {
+ int32_t iMid = (iStart + iEnd) / 2;
+ const FPF_SKIAFONTMAP* pItem = &g_SkiaSansFontMap[iMid];
+ if (dwHash < pItem->dwFamily) {
+ iEnd = iMid - 1;
+ } else if (dwHash > pItem->dwFamily) {
+ iStart = iMid + 1;
+ } else {
+ return pItem->dwSubSt;
+ }
+ }
+ return 0;
+}
+static uint32_t FPF_GetHashCode_StringA(const FX_CHAR* pStr,
+ int32_t iLength,
+ FX_BOOL bIgnoreCase = FALSE) {
+ if (!pStr) {
+ return 0;
+ }
+ if (iLength < 0) {
+ iLength = FXSYS_strlen(pStr);
+ }
+ const FX_CHAR* pStrEnd = pStr + iLength;
+ uint32_t uHashCode = 0;
+ if (bIgnoreCase) {
+ while (pStr < pStrEnd) {
+ uHashCode = 31 * uHashCode + FXSYS_tolower(*pStr++);
+ }
+ } else {
+ while (pStr < pStrEnd) {
+ uHashCode = 31 * uHashCode + *pStr++;
+ }
+ }
+ return uHashCode;
+}
+enum FPF_SKIACHARSET {
+ FPF_SKIACHARSET_Ansi = 1 << 0,
+ FPF_SKIACHARSET_Default = 1 << 1,
+ FPF_SKIACHARSET_Symbol = 1 << 2,
+ FPF_SKIACHARSET_ShiftJIS = 1 << 3,
+ FPF_SKIACHARSET_Korean = 1 << 4,
+ FPF_SKIACHARSET_Johab = 1 << 5,
+ FPF_SKIACHARSET_GB2312 = 1 << 6,
+ FPF_SKIACHARSET_BIG5 = 1 << 7,
+ FPF_SKIACHARSET_Greek = 1 << 8,
+ FPF_SKIACHARSET_Turkish = 1 << 9,
+ FPF_SKIACHARSET_Vietnamese = 1 << 10,
+ FPF_SKIACHARSET_Hebrew = 1 << 11,
+ FPF_SKIACHARSET_Arabic = 1 << 12,
+ FPF_SKIACHARSET_Baltic = 1 << 13,
+ FPF_SKIACHARSET_Cyrillic = 1 << 14,
+ FPF_SKIACHARSET_Thai = 1 << 15,
+ FPF_SKIACHARSET_EeasternEuropean = 1 << 16,
+ FPF_SKIACHARSET_PC = 1 << 17,
+ FPF_SKIACHARSET_OEM = 1 << 18,
+};
+static FX_DWORD FPF_SkiaGetCharset(uint8_t uCharset) {
+ switch (uCharset) {
+ case FXFONT_ANSI_CHARSET:
+ return FPF_SKIACHARSET_Ansi;
+ case FXFONT_DEFAULT_CHARSET:
+ return FPF_SKIACHARSET_Default;
+ case FXFONT_SYMBOL_CHARSET:
+ return FPF_SKIACHARSET_Symbol;
+ case FXFONT_SHIFTJIS_CHARSET:
+ return FPF_SKIACHARSET_ShiftJIS;
+ case FXFONT_HANGEUL_CHARSET:
+ return FPF_SKIACHARSET_Korean;
+ case FXFONT_GB2312_CHARSET:
+ return FPF_SKIACHARSET_GB2312;
+ case FXFONT_CHINESEBIG5_CHARSET:
+ return FPF_SKIACHARSET_BIG5;
+ case FXFONT_GREEK_CHARSET:
+ return FPF_SKIACHARSET_Greek;
+ case FXFONT_TURKISH_CHARSET:
+ return FPF_SKIACHARSET_Turkish;
+ case FXFONT_HEBREW_CHARSET:
+ return FPF_SKIACHARSET_Hebrew;
+ case FXFONT_ARABIC_CHARSET:
+ return FPF_SKIACHARSET_Arabic;
+ case FXFONT_BALTIC_CHARSET:
+ return FPF_SKIACHARSET_Baltic;
+ case FXFONT_RUSSIAN_CHARSET:
+ return FPF_SKIACHARSET_Cyrillic;
+ case FXFONT_THAI_CHARSET:
+ return FPF_SKIACHARSET_Thai;
+ case FXFONT_EASTEUROPE_CHARSET:
+ return FPF_SKIACHARSET_EeasternEuropean;
+ }
+ return FPF_SKIACHARSET_Default;
+}
+static FX_DWORD FPF_SKIANormalizeFontName(const CFX_ByteStringC& bsfamily) {
+ FX_DWORD dwHash = 0;
+ int32_t iLength = bsfamily.GetLength();
+ const FX_CHAR* pBuffer = bsfamily.GetCStr();
+ for (int32_t i = 0; i < iLength; i++) {
+ FX_CHAR ch = pBuffer[i];
+ if (ch == ' ' || ch == '-' || ch == ',') {
+ continue;
+ }
+ dwHash = 31 * dwHash + FXSYS_tolower(ch);
+ }
+ return dwHash;
+}
+static FX_DWORD FPF_SKIAGetFamilyHash(const CFX_ByteStringC& bsFamily,
+ FX_DWORD dwStyle,
+ uint8_t uCharset) {
+ CFX_ByteString bsFont(bsFamily);
+ if (dwStyle & FXFONT_BOLD) {
+ bsFont += "Bold";
+ }
+ if (dwStyle & FXFONT_ITALIC) {
+ bsFont += "Italic";
+ }
+ if (dwStyle & FXFONT_SERIF) {
+ bsFont += "Serif";
+ }
+ bsFont += uCharset;
+ return FPF_GetHashCode_StringA(bsFont.c_str(), bsFont.GetLength(), TRUE);
+}
+static FX_BOOL FPF_SkiaIsCJK(uint8_t uCharset) {
+ return (uCharset == FXFONT_GB2312_CHARSET) ||
+ (uCharset == FXFONT_CHINESEBIG5_CHARSET) ||
+ (uCharset == FXFONT_HANGEUL_CHARSET) ||
+ (uCharset == FXFONT_SHIFTJIS_CHARSET);
+}
+static FX_BOOL FPF_SkiaMaybeSymbol(const CFX_ByteStringC& bsFacename) {
+ CFX_ByteString bsName = bsFacename;
+ bsName.MakeLower();
+ return bsName.Find("symbol") > -1;
+}
+static FX_BOOL FPF_SkiaMaybeArabic(const CFX_ByteStringC& bsFacename) {
+ CFX_ByteString bsName = bsFacename;
+ bsName.MakeLower();
+ return bsName.Find("arabic") > -1;
+}
+CFPF_SkiaFontMgr::CFPF_SkiaFontMgr() : m_bLoaded(FALSE), m_FTLibrary(NULL) {}
+CFPF_SkiaFontMgr::~CFPF_SkiaFontMgr() {
+ for (const auto& pair : m_FamilyFonts) {
+ if (pair.second)
+ pair.second->Release();
+ }
+ m_FamilyFonts.clear();
+ for (auto it = m_FontFaces.rbegin(); it != m_FontFaces.rend(); ++it) {
+ delete *it;
+ }
+ m_FontFaces.clear();
+ if (m_FTLibrary) {
+ FXFT_Done_FreeType(m_FTLibrary);
+ }
+}
+FX_BOOL CFPF_SkiaFontMgr::InitFTLibrary() {
+ if (!m_FTLibrary) {
+ FXFT_Init_FreeType(&m_FTLibrary);
+ }
+ return m_FTLibrary != NULL;
+}
+void CFPF_SkiaFontMgr::LoadSystemFonts() {
+ if (m_bLoaded) {
+ return;
+ }
+ ScanPath("/system/fonts");
+ OutputSystemFonts();
+ m_bLoaded = TRUE;
+}
+void CFPF_SkiaFontMgr::LoadPrivateFont(IFX_FileRead* pFontFile) {}
+void CFPF_SkiaFontMgr::LoadPrivateFont(const CFX_ByteStringC& bsFileName) {}
+void CFPF_SkiaFontMgr::LoadPrivateFont(void* pBuffer, size_t szBuffer) {}
+IFPF_Font* CFPF_SkiaFontMgr::CreateFont(const CFX_ByteStringC& bsFamilyname,
+ uint8_t uCharset,
+ FX_DWORD dwStyle,
+ FX_DWORD dwMatch) {
+ FX_DWORD dwHash = FPF_SKIAGetFamilyHash(bsFamilyname, dwStyle, uCharset);
+ auto it = m_FamilyFonts.find(dwHash);
+ if (it != m_FamilyFonts.end() && it->second)
+ return it->second->Retain();
+
+ FX_DWORD dwFaceName = FPF_SKIANormalizeFontName(bsFamilyname);
+ FX_DWORD dwSubst = FPF_SkiaGetSubstFont(dwFaceName);
+ FX_DWORD dwSubstSans = FPF_SkiaGetSansFont(dwFaceName);
+ FX_BOOL bMaybeSymbol = FPF_SkiaMaybeSymbol(bsFamilyname);
+ if (uCharset != FXFONT_ARABIC_CHARSET && FPF_SkiaMaybeArabic(bsFamilyname)) {
+ uCharset = FXFONT_ARABIC_CHARSET;
+ } else if (uCharset == FXFONT_ANSI_CHARSET &&
+ (dwMatch & FPF_MATCHFONT_REPLACEANSI)) {
+ uCharset = FXFONT_DEFAULT_CHARSET;
+ }
+ int32_t nExpectVal = FPF_SKIAMATCHWEIGHT_NAME1 + FPF_SKIAMATCHWEIGHT_1 * 3 +
+ FPF_SKIAMATCHWEIGHT_2 * 2;
+ int32_t nItem = -1;
+ int32_t nMax = -1;
+ int32_t nGlyphNum = 0;
+ for (auto it = m_FontFaces.rbegin(); it != m_FontFaces.rend(); ++it) {
+ CFPF_SkiaPathFont* pFontDes = static_cast<CFPF_SkiaPathFont*>(*it);
+ if (!(pFontDes->m_dwCharsets & FPF_SkiaGetCharset(uCharset))) {
+ continue;
+ }
+ int32_t nFind = 0;
+ FX_DWORD dwSysFontName = FPF_SKIANormalizeFontName(pFontDes->m_pFamily);
+ if (dwFaceName == dwSysFontName) {
+ nFind += FPF_SKIAMATCHWEIGHT_NAME1;
+ }
+ bool bMatchedName = (nFind == FPF_SKIAMATCHWEIGHT_NAME1);
+ if ((dwStyle & FXFONT_BOLD) == (pFontDes->m_dwStyle & FXFONT_BOLD)) {
+ nFind += FPF_SKIAMATCHWEIGHT_1;
+ }
+ if ((dwStyle & FXFONT_ITALIC) == (pFontDes->m_dwStyle & FXFONT_ITALIC)) {
+ nFind += FPF_SKIAMATCHWEIGHT_1;
+ }
+ if ((dwStyle & FXFONT_FIXED_PITCH) ==
+ (pFontDes->m_dwStyle & FXFONT_FIXED_PITCH)) {
+ nFind += FPF_SKIAMATCHWEIGHT_2;
+ }
+ if ((dwStyle & FXFONT_SERIF) == (pFontDes->m_dwStyle & FXFONT_SERIF)) {
+ nFind += FPF_SKIAMATCHWEIGHT_1;
+ }
+ if ((dwStyle & FXFONT_SCRIPT) == (pFontDes->m_dwStyle & FXFONT_SCRIPT)) {
+ nFind += FPF_SKIAMATCHWEIGHT_2;
+ }
+ if (dwSubst == dwSysFontName || dwSubstSans == dwSysFontName) {
+ nFind += FPF_SKIAMATCHWEIGHT_NAME2;
+ bMatchedName = true;
+ }
+ if (uCharset == FXFONT_DEFAULT_CHARSET || bMaybeSymbol) {
+ if (nFind > nMax && bMatchedName) {
+ nMax = nFind;
+ nItem = it - m_FontFaces.rbegin();
+ }
+ } else if (FPF_SkiaIsCJK(uCharset)) {
+ if (bMatchedName || pFontDes->m_iGlyphNum > nGlyphNum) {
+ nItem = it - m_FontFaces.rbegin();
+ nGlyphNum = pFontDes->m_iGlyphNum;
+ }
+ } else if (nFind > nMax) {
+ nMax = nFind;
+ nItem = it - m_FontFaces.rbegin();
+ }
+ if (nExpectVal <= nFind) {
+ nItem = it - m_FontFaces.rbegin();
+ break;
+ }
+ }
+ if (nItem > -1) {
+ CFPF_SkiaFontDescriptor* pFontDes = m_FontFaces[nItem];
+ CFPF_SkiaFont* pFont = new CFPF_SkiaFont;
+ if (pFont->InitFont(this, pFontDes, bsFamilyname, dwStyle, uCharset)) {
+ m_FamilyFonts[dwHash] = pFont;
+ return pFont->Retain();
+ }
+ pFont->Release();
+ }
+ return NULL;
+}
+FXFT_Face CFPF_SkiaFontMgr::GetFontFace(IFX_FileRead* pFileRead,
+ int32_t iFaceIndex) {
+ if (!pFileRead) {
+ return NULL;
+ }
+ if (pFileRead->GetSize() == 0) {
+ return NULL;
+ }
+ if (iFaceIndex < 0) {
+ return NULL;
+ }
+ FXFT_StreamRec streamRec;
+ FXSYS_memset(&streamRec, 0, sizeof(FXFT_StreamRec));
+ streamRec.size = pFileRead->GetSize();
+ streamRec.descriptor.pointer = pFileRead;
+ streamRec.read = FPF_SkiaStream_Read;
+ streamRec.close = FPF_SkiaStream_Close;
+ FXFT_Open_Args args;
+ args.flags = FT_OPEN_STREAM;
+ args.stream = &streamRec;
+ FXFT_Face face;
+ if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
+ return NULL;
+ }
+ FXFT_Set_Pixel_Sizes(face, 0, 64);
+ return face;
+}
+FXFT_Face CFPF_SkiaFontMgr::GetFontFace(const CFX_ByteStringC& bsFile,
+ int32_t iFaceIndex) {
+ if (bsFile.IsEmpty()) {
+ return NULL;
+ }
+ if (iFaceIndex < 0) {
+ return NULL;
+ }
+ FXFT_Open_Args args;
+ args.flags = FT_OPEN_PATHNAME;
+ args.pathname = (FT_String*)bsFile.GetCStr();
+ FXFT_Face face;
+ if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
+ return FALSE;
+ }
+ FXFT_Set_Pixel_Sizes(face, 0, 64);
+ return face;
+}
+FXFT_Face CFPF_SkiaFontMgr::GetFontFace(const uint8_t* pBuffer,
+ size_t szBuffer,
+ int32_t iFaceIndex) {
+ if (!pBuffer || szBuffer < 1) {
+ return NULL;
+ }
+ if (iFaceIndex < 0) {
+ return NULL;
+ }
+ FXFT_Open_Args args;
+ args.flags = FT_OPEN_MEMORY;
+ args.memory_base = pBuffer;
+ args.memory_size = szBuffer;
+ FXFT_Face face;
+ if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
+ return FALSE;
+ }
+ FXFT_Set_Pixel_Sizes(face, 0, 64);
+ return face;
+}
+void CFPF_SkiaFontMgr::ScanPath(const CFX_ByteStringC& path) {
+ void* handle = FX_OpenFolder(path.GetCStr());
+ if (!handle) {
+ return;
+ }
+ CFX_ByteString filename;
+ FX_BOOL bFolder = FALSE;
+ while (FX_GetNextFile(handle, filename, bFolder)) {
+ if (bFolder) {
+ if (filename == "." || filename == "..") {
+ continue;
+ }
+ } else {
+ CFX_ByteString ext = filename.Right(4);
+ ext.MakeLower();
+ if (ext != ".ttf" && ext != ".ttc" && ext != ".otf") {
+ continue;
+ }
+ }
+ CFX_ByteString fullpath = path;
+ fullpath += "/";
+ fullpath += filename;
+ if (bFolder) {
+ ScanPath(fullpath);
+ } else {
+ ScanFile(fullpath);
+ }
+ }
+ FX_CloseFolder(handle);
+}
+void CFPF_SkiaFontMgr::ScanFile(const CFX_ByteStringC& file) {
+ FXFT_Face face = GetFontFace(file);
+ if (face) {
+ CFPF_SkiaPathFont* pFontDesc = new CFPF_SkiaPathFont;
+ pFontDesc->SetPath(file.GetCStr());
+ ReportFace(face, pFontDesc);
+ m_FontFaces.push_back(pFontDesc);
+ FXFT_Done_Face(face);
+ }
+}
+static const FX_DWORD g_FPFSkiaFontCharsets[] = {
+ FPF_SKIACHARSET_Ansi,
+ FPF_SKIACHARSET_EeasternEuropean,
+ FPF_SKIACHARSET_Cyrillic,
+ FPF_SKIACHARSET_Greek,
+ FPF_SKIACHARSET_Turkish,
+ FPF_SKIACHARSET_Hebrew,
+ FPF_SKIACHARSET_Arabic,
+ FPF_SKIACHARSET_Baltic,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ FPF_SKIACHARSET_Thai,
+ FPF_SKIACHARSET_ShiftJIS,
+ FPF_SKIACHARSET_GB2312,
+ FPF_SKIACHARSET_Korean,
+ FPF_SKIACHARSET_BIG5,
+ FPF_SKIACHARSET_Johab,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ FPF_SKIACHARSET_OEM,
+ FPF_SKIACHARSET_Symbol,
+};
+static FX_DWORD FPF_SkiaGetFaceCharset(TT_OS2* pOS2) {
+ FX_DWORD dwCharset = 0;
+ if (pOS2) {
+ for (int32_t i = 0; i < 32; i++) {
+ if (pOS2->ulCodePageRange1 & (1 << i)) {
+ dwCharset |= g_FPFSkiaFontCharsets[i];
+ }
+ }
+ }
+ dwCharset |= FPF_SKIACHARSET_Default;
+ return dwCharset;
+}
+void CFPF_SkiaFontMgr::ReportFace(FXFT_Face face,
+ CFPF_SkiaFontDescriptor* pFontDesc) {
+ if (!face || !pFontDesc) {
+ return;
+ }
+ pFontDesc->SetFamily(FXFT_Get_Face_Family_Name(face));
+ if (FXFT_Is_Face_Bold(face)) {
+ pFontDesc->m_dwStyle |= FXFONT_BOLD;
+ }
+ if (FXFT_Is_Face_Italic(face)) {
+ pFontDesc->m_dwStyle |= FXFONT_ITALIC;
+ }
+ if (FT_IS_FIXED_WIDTH(face)) {
+ pFontDesc->m_dwStyle |= FXFONT_FIXED_PITCH;
+ }
+ TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2);
+ if (pOS2) {
+ if (pOS2->ulCodePageRange1 & (1 << 31)) {
+ pFontDesc->m_dwStyle |= FXFONT_SYMBOLIC;
+ }
+ if (pOS2->panose[0] == 2) {
+ uint8_t uSerif = pOS2->panose[1];
+ if ((uSerif > 1 && uSerif < 10) || uSerif > 13) {
+ pFontDesc->m_dwStyle |= FXFONT_SERIF;
+ }
+ }
+ }
+ if (pOS2 && (pOS2->ulCodePageRange1 & (1 << 31))) {
+ pFontDesc->m_dwStyle |= FXFONT_SYMBOLIC;
+ }
+ pFontDesc->m_dwCharsets = FPF_SkiaGetFaceCharset(pOS2);
+ pFontDesc->m_iFaceIndex = face->face_index;
+ pFontDesc->m_iGlyphNum = face->num_glyphs;
+}
+void CFPF_SkiaFontMgr::OutputSystemFonts() {}
+#endif