b18e9c83be842a8d6377fbda8c6cc0bbbcc6350e
[pdfium.git] / core / src / fxge / android / fpf_skiafontmgr.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "fx_fpf.h"
8 #if _FX_OS_ == _FX_ANDROID_
9 #define FPF_SKIAMATCHWEIGHT_NAME1 62
10 #define FPF_SKIAMATCHWEIGHT_NAME2 60
11 #define FPF_SKIAMATCHWEIGHT_1 16
12 #define FPF_SKIAMATCHWEIGHT_2 8
13 #include "fpf_skiafontmgr.h"
14 #include "fpf_skiafont.h"
15 #ifdef __cplusplus
16 extern "C" {
17 #endif
18 static unsigned long FPF_SkiaStream_Read(FXFT_Stream stream,
19                                          unsigned long offset,
20                                          unsigned char* buffer,
21                                          unsigned long count) {
22   IFX_FileRead* pFileRead = (IFX_FileRead*)stream->descriptor.pointer;
23   if (!pFileRead) {
24     return 0;
25   }
26   if (count > 0) {
27     if (pFileRead->ReadBlock(buffer, (FX_FILESIZE)offset, (size_t)count) !=
28         count) {
29       return 0;
30     }
31   }
32   return count;
33 }
34 static void FPF_SkiaStream_Close(FXFT_Stream stream) {}
35 #ifdef __cplusplus
36 };
37 #endif
38 typedef struct _FPF_SKIAFONTMAP {
39   FX_DWORD dwFamily;
40   FX_DWORD dwSubSt;
41 } FPF_SKIAFONTMAP, *FPF_LPSKIAFONTMAP;
42 typedef FPF_SKIAFONTMAP const* FPF_LPCSKIAFONTMAP;
43 static const FPF_SKIAFONTMAP g_SkiaFontmap[] = {
44     {0x58c5083, 0xc8d2e345},  {0x5dfade2, 0xe1633081},
45     {0x684317d, 0xe1633081},  {0x14ee2d13, 0xc8d2e345},
46     {0x3918fe2d, 0xbbeeec72}, {0x3b98b31c, 0xe1633081},
47     {0x3d49f40e, 0xe1633081}, {0x432c41c5, 0xe1633081},
48     {0x491b6ad0, 0xe1633081}, {0x5612cab1, 0x59b9f8f1},
49     {0x779ce19d, 0xc8d2e345}, {0x7cc9510b, 0x59b9f8f1},
50     {0x83746053, 0xbbeeec72}, {0xaaa60c03, 0xbbeeec72},
51     {0xbf85ff26, 0xe1633081}, {0xc04fe601, 0xbbeeec72},
52     {0xca3812d5, 0x59b9f8f1}, {0xca383e15, 0x59b9f8f1},
53     {0xcad5eaf6, 0x59b9f8f1}, {0xcb7a04c8, 0xc8d2e345},
54     {0xfb4ce0de, 0xe1633081},
55 };
56 FX_DWORD FPF_SkiaGetSubstFont(FX_DWORD dwHash) {
57   int32_t iStart = 0;
58   int32_t iEnd = sizeof(g_SkiaFontmap) / sizeof(FPF_SKIAFONTMAP);
59   while (iStart <= iEnd) {
60     int32_t iMid = (iStart + iEnd) / 2;
61     FPF_LPCSKIAFONTMAP pItem = &g_SkiaFontmap[iMid];
62     if (dwHash < pItem->dwFamily) {
63       iEnd = iMid - 1;
64     } else if (dwHash > pItem->dwFamily) {
65       iStart = iMid + 1;
66     } else {
67       return pItem->dwSubSt;
68     }
69   }
70   return 0;
71 }
72 static const FPF_SKIAFONTMAP g_SkiaSansFontMap[] = {
73     {0x58c5083, 0xd5b8d10f},  {0x14ee2d13, 0xd5b8d10f},
74     {0x779ce19d, 0xd5b8d10f}, {0xcb7a04c8, 0xd5b8d10f},
75     {0xfb4ce0de, 0xd5b8d10f},
76 };
77 FX_DWORD FPF_SkiaGetSansFont(FX_DWORD dwHash) {
78   int32_t iStart = 0;
79   int32_t iEnd = sizeof(g_SkiaSansFontMap) / sizeof(FPF_SKIAFONTMAP);
80   while (iStart <= iEnd) {
81     int32_t iMid = (iStart + iEnd) / 2;
82     FPF_LPCSKIAFONTMAP pItem = &g_SkiaSansFontMap[iMid];
83     if (dwHash < pItem->dwFamily) {
84       iEnd = iMid - 1;
85     } else if (dwHash > pItem->dwFamily) {
86       iStart = iMid + 1;
87     } else {
88       return pItem->dwSubSt;
89     }
90   }
91   return 0;
92 }
93 static uint32_t FPF_GetHashCode_StringA(const FX_CHAR* pStr,
94                                         int32_t iLength,
95                                         FX_BOOL bIgnoreCase = FALSE) {
96   if (!pStr) {
97     return 0;
98   }
99   if (iLength < 0) {
100     iLength = FXSYS_strlen(pStr);
101   }
102   const FX_CHAR* pStrEnd = pStr + iLength;
103   uint32_t uHashCode = 0;
104   if (bIgnoreCase) {
105     while (pStr < pStrEnd) {
106       uHashCode = 31 * uHashCode + FXSYS_tolower(*pStr++);
107     }
108   } else {
109     while (pStr < pStrEnd) {
110       uHashCode = 31 * uHashCode + *pStr++;
111     }
112   }
113   return uHashCode;
114 }
115 enum FPF_SKIACHARSET {
116   FPF_SKIACHARSET_Ansi = 1 << 0,
117   FPF_SKIACHARSET_Default = 1 << 1,
118   FPF_SKIACHARSET_Symbol = 1 << 2,
119   FPF_SKIACHARSET_ShiftJIS = 1 << 3,
120   FPF_SKIACHARSET_Korean = 1 << 4,
121   FPF_SKIACHARSET_Johab = 1 << 5,
122   FPF_SKIACHARSET_GB2312 = 1 << 6,
123   FPF_SKIACHARSET_BIG5 = 1 << 7,
124   FPF_SKIACHARSET_Greek = 1 << 8,
125   FPF_SKIACHARSET_Turkish = 1 << 9,
126   FPF_SKIACHARSET_Vietnamese = 1 << 10,
127   FPF_SKIACHARSET_Hebrew = 1 << 11,
128   FPF_SKIACHARSET_Arabic = 1 << 12,
129   FPF_SKIACHARSET_Baltic = 1 << 13,
130   FPF_SKIACHARSET_Cyrillic = 1 << 14,
131   FPF_SKIACHARSET_Thai = 1 << 15,
132   FPF_SKIACHARSET_EeasternEuropean = 1 << 16,
133   FPF_SKIACHARSET_PC = 1 << 17,
134   FPF_SKIACHARSET_OEM = 1 << 18,
135 };
136 static FX_DWORD FPF_SkiaGetCharset(uint8_t uCharset) {
137   switch (uCharset) {
138     case FXFONT_ANSI_CHARSET:
139       return FPF_SKIACHARSET_Ansi;
140     case FXFONT_DEFAULT_CHARSET:
141       return FPF_SKIACHARSET_Default;
142     case FXFONT_SYMBOL_CHARSET:
143       return FPF_SKIACHARSET_Symbol;
144     case FXFONT_SHIFTJIS_CHARSET:
145       return FPF_SKIACHARSET_ShiftJIS;
146     case FXFONT_HANGEUL_CHARSET:
147       return FPF_SKIACHARSET_Korean;
148     case FXFONT_GB2312_CHARSET:
149       return FPF_SKIACHARSET_GB2312;
150     case FXFONT_CHINESEBIG5_CHARSET:
151       return FPF_SKIACHARSET_BIG5;
152     case FXFONT_GREEK_CHARSET:
153       return FPF_SKIACHARSET_Greek;
154     case FXFONT_TURKISH_CHARSET:
155       return FPF_SKIACHARSET_Turkish;
156     case FXFONT_HEBREW_CHARSET:
157       return FPF_SKIACHARSET_Hebrew;
158     case FXFONT_ARABIC_CHARSET:
159       return FPF_SKIACHARSET_Arabic;
160     case FXFONT_BALTIC_CHARSET:
161       return FPF_SKIACHARSET_Baltic;
162     case FXFONT_RUSSIAN_CHARSET:
163       return FPF_SKIACHARSET_Cyrillic;
164     case FXFONT_THAI_CHARSET:
165       return FPF_SKIACHARSET_Thai;
166     case FXFONT_EASTEUROPE_CHARSET:
167       return FPF_SKIACHARSET_EeasternEuropean;
168   }
169   return FPF_SKIACHARSET_Default;
170 }
171 static FX_DWORD FPF_SKIANormalizeFontName(const CFX_ByteStringC& bsfamily) {
172   FX_DWORD dwHash = 0;
173   int32_t iLength = bsfamily.GetLength();
174   const FX_CHAR* pBuffer = bsfamily.GetCStr();
175   for (int32_t i = 0; i < iLength; i++) {
176     FX_CHAR ch = pBuffer[i];
177     if (ch == ' ' || ch == '-' || ch == ',') {
178       continue;
179     }
180     dwHash = 31 * dwHash + FXSYS_tolower(ch);
181   }
182   return dwHash;
183 }
184 static FX_DWORD FPF_SKIAGetFamilyHash(const CFX_ByteStringC& bsFamily,
185                                       FX_DWORD dwStyle,
186                                       uint8_t uCharset) {
187   CFX_ByteString bsFont(bsFamily);
188   if (dwStyle & FXFONT_BOLD) {
189     bsFont += "Bold";
190   }
191   if (dwStyle & FXFONT_ITALIC) {
192     bsFont += "Italic";
193   }
194   if (dwStyle & FXFONT_SERIF) {
195     bsFont += "Serif";
196   }
197   bsFont += uCharset;
198   return FPF_GetHashCode_StringA(bsFont.c_str(), bsFont.GetLength(), TRUE);
199 }
200 static FX_BOOL FPF_SkiaIsCJK(uint8_t uCharset) {
201   return (uCharset == FXFONT_GB2312_CHARSET) ||
202          (uCharset == FXFONT_CHINESEBIG5_CHARSET) ||
203          (uCharset == FXFONT_HANGEUL_CHARSET) ||
204          (uCharset == FXFONT_SHIFTJIS_CHARSET);
205 }
206 static FX_BOOL FPF_SkiaMaybeSymbol(const CFX_ByteStringC& bsFacename) {
207   CFX_ByteString bsName = bsFacename;
208   bsName.MakeLower();
209   return bsName.Find("symbol") > -1;
210 }
211 static FX_BOOL FPF_SkiaMaybeArabic(const CFX_ByteStringC& bsFacename) {
212   CFX_ByteString bsName = bsFacename;
213   bsName.MakeLower();
214   return bsName.Find("arabic") > -1;
215 }
216 CFPF_SkiaFontMgr::CFPF_SkiaFontMgr() : m_bLoaded(FALSE), m_FTLibrary(NULL) {}
217 CFPF_SkiaFontMgr::~CFPF_SkiaFontMgr() {
218   void* pkey = NULL;
219   CFPF_SkiaFont* pValue = NULL;
220   FX_POSITION pos = m_FamilyFonts.GetStartPosition();
221   while (pos) {
222     m_FamilyFonts.GetNextAssoc(pos, pkey, (void*&)pValue);
223     if (pValue) {
224       pValue->Release();
225     }
226   }
227   m_FamilyFonts.RemoveAll();
228   for (int32_t i = m_FontFaces.GetUpperBound(); i >= 0; i--) {
229     CFPF_SkiaFontDescriptor* pFont =
230         (CFPF_SkiaFontDescriptor*)m_FontFaces.ElementAt(i);
231     delete pFont;
232   }
233   m_FontFaces.RemoveAll();
234   if (m_FTLibrary) {
235     FXFT_Done_FreeType(m_FTLibrary);
236   }
237 }
238 FX_BOOL CFPF_SkiaFontMgr::InitFTLibrary() {
239   if (m_FTLibrary == NULL) {
240     FXFT_Init_FreeType(&m_FTLibrary);
241   }
242   return m_FTLibrary != NULL;
243 }
244 void CFPF_SkiaFontMgr::LoadSystemFonts() {
245   if (m_bLoaded) {
246     return;
247   }
248   ScanPath(FX_BSTRC("/system/fonts"));
249   OutputSystemFonts();
250   m_bLoaded = TRUE;
251 }
252 void CFPF_SkiaFontMgr::LoadPrivateFont(IFX_FileRead* pFontFile) {}
253 void CFPF_SkiaFontMgr::LoadPrivateFont(const CFX_ByteStringC& bsFileName) {}
254 void CFPF_SkiaFontMgr::LoadPrivateFont(void* pBuffer, size_t szBuffer) {}
255 IFPF_Font* CFPF_SkiaFontMgr::CreateFont(const CFX_ByteStringC& bsFamilyname,
256                                         uint8_t uCharset,
257                                         FX_DWORD dwStyle,
258                                         FX_DWORD dwMatch) {
259   FX_DWORD dwHash = FPF_SKIAGetFamilyHash(bsFamilyname, dwStyle, uCharset);
260   IFPF_Font* pFont = NULL;
261   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
262     if (pFont) {
263       return pFont->Retain();
264     }
265   }
266   FX_DWORD dwFaceName = FPF_SKIANormalizeFontName(bsFamilyname);
267   FX_DWORD dwSubst = FPF_SkiaGetSubstFont(dwFaceName);
268   FX_DWORD dwSubstSans = FPF_SkiaGetSansFont(dwFaceName);
269   FX_BOOL bMaybeSymbol = FPF_SkiaMaybeSymbol(bsFamilyname);
270   if (uCharset != FXFONT_ARABIC_CHARSET && FPF_SkiaMaybeArabic(bsFamilyname)) {
271     uCharset = FXFONT_ARABIC_CHARSET;
272   } else if (uCharset == FXFONT_ANSI_CHARSET &&
273              (dwMatch & FPF_MATCHFONT_REPLACEANSI)) {
274     uCharset = FXFONT_DEFAULT_CHARSET;
275   }
276   int32_t nExpectVal = FPF_SKIAMATCHWEIGHT_NAME1 + FPF_SKIAMATCHWEIGHT_1 * 3 +
277                        FPF_SKIAMATCHWEIGHT_2 * 2;
278   int32_t nItem = -1;
279   int32_t nMax = -1;
280   int32_t nGlyphNum = 0;
281   for (int32_t i = m_FontFaces.GetUpperBound(); i >= 0; i--) {
282     CFPF_SkiaPathFont* pFontDes = (CFPF_SkiaPathFont*)m_FontFaces.ElementAt(i);
283     if (!(pFontDes->m_dwCharsets & FPF_SkiaGetCharset(uCharset))) {
284       continue;
285     }
286     int32_t nFind = 0;
287     FX_DWORD dwSysFontName = FPF_SKIANormalizeFontName(pFontDes->m_pFamily);
288     if (dwFaceName == dwSysFontName) {
289       nFind += FPF_SKIAMATCHWEIGHT_NAME1;
290     }
291     FX_BOOL bMatchedName = (nFind == FPF_SKIAMATCHWEIGHT_NAME1);
292     if ((dwStyle & FXFONT_BOLD) == (pFontDes->m_dwStyle & FXFONT_BOLD)) {
293       nFind += FPF_SKIAMATCHWEIGHT_1;
294     }
295     if ((dwStyle & FXFONT_ITALIC) == (pFontDes->m_dwStyle & FXFONT_ITALIC)) {
296       nFind += FPF_SKIAMATCHWEIGHT_1;
297     }
298     if ((dwStyle & FXFONT_FIXED_PITCH) ==
299         (pFontDes->m_dwStyle & FXFONT_FIXED_PITCH)) {
300       nFind += FPF_SKIAMATCHWEIGHT_2;
301     }
302     if ((dwStyle & FXFONT_SERIF) == (pFontDes->m_dwStyle & FXFONT_SERIF)) {
303       nFind += FPF_SKIAMATCHWEIGHT_1;
304     }
305     if ((dwStyle & FXFONT_SCRIPT) == (pFontDes->m_dwStyle & FXFONT_SCRIPT)) {
306       nFind += FPF_SKIAMATCHWEIGHT_2;
307     }
308     if (dwSubst == dwSysFontName || dwSubstSans == dwSysFontName) {
309       nFind += FPF_SKIAMATCHWEIGHT_NAME2;
310       bMatchedName = TRUE;
311     }
312     if (uCharset == FXFONT_DEFAULT_CHARSET || bMaybeSymbol) {
313       if (nFind > nMax && bMatchedName) {
314         nMax = nFind;
315         nItem = i;
316       }
317     } else if (FPF_SkiaIsCJK(uCharset)) {
318       if (bMatchedName || pFontDes->m_iGlyphNum > nGlyphNum) {
319         nItem = i;
320         nGlyphNum = pFontDes->m_iGlyphNum;
321       }
322     } else if (nFind > nMax) {
323       nMax = nFind;
324       nItem = i;
325     }
326     if (nExpectVal <= nFind) {
327       nItem = i;
328       break;
329     }
330   }
331   if (nItem > -1) {
332     CFPF_SkiaFontDescriptor* pFontDes =
333         (CFPF_SkiaFontDescriptor*)m_FontFaces.ElementAt(nItem);
334     CFPF_SkiaFont* pFont = new CFPF_SkiaFont;
335     if (pFont->InitFont(this, pFontDes, bsFamilyname, dwStyle, uCharset)) {
336       m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
337       return pFont->Retain();
338     }
339     pFont->Release();
340   }
341   return NULL;
342 }
343 FXFT_Face CFPF_SkiaFontMgr::GetFontFace(IFX_FileRead* pFileRead,
344                                         int32_t iFaceIndex) {
345   if (!pFileRead) {
346     return NULL;
347   }
348   if (pFileRead->GetSize() == 0) {
349     return NULL;
350   }
351   if (iFaceIndex < 0) {
352     return NULL;
353   }
354   FXFT_StreamRec streamRec;
355   FXSYS_memset(&streamRec, 0, sizeof(FXFT_StreamRec));
356   streamRec.size = pFileRead->GetSize();
357   streamRec.descriptor.pointer = pFileRead;
358   streamRec.read = FPF_SkiaStream_Read;
359   streamRec.close = FPF_SkiaStream_Close;
360   FXFT_Open_Args args;
361   args.flags = FT_OPEN_STREAM;
362   args.stream = &streamRec;
363   FXFT_Face face;
364   if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
365     return NULL;
366   }
367   FXFT_Set_Pixel_Sizes(face, 0, 64);
368   return face;
369 }
370 FXFT_Face CFPF_SkiaFontMgr::GetFontFace(const CFX_ByteStringC& bsFile,
371                                         int32_t iFaceIndex) {
372   if (bsFile.IsEmpty()) {
373     return NULL;
374   }
375   if (iFaceIndex < 0) {
376     return NULL;
377   }
378   FXFT_Open_Args args;
379   args.flags = FT_OPEN_PATHNAME;
380   args.pathname = (FT_String*)bsFile.GetCStr();
381   FXFT_Face face;
382   if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
383     return FALSE;
384   }
385   FXFT_Set_Pixel_Sizes(face, 0, 64);
386   return face;
387 }
388 FXFT_Face CFPF_SkiaFontMgr::GetFontFace(const uint8_t* pBuffer,
389                                         size_t szBuffer,
390                                         int32_t iFaceIndex) {
391   if (!pBuffer || szBuffer < 1) {
392     return NULL;
393   }
394   if (iFaceIndex < 0) {
395     return NULL;
396   }
397   FXFT_Open_Args args;
398   args.flags = FT_OPEN_MEMORY;
399   args.memory_base = pBuffer;
400   args.memory_size = szBuffer;
401   FXFT_Face face;
402   if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
403     return FALSE;
404   }
405   FXFT_Set_Pixel_Sizes(face, 0, 64);
406   return face;
407 }
408 void CFPF_SkiaFontMgr::ScanPath(const CFX_ByteStringC& path) {
409   void* handle = FX_OpenFolder(path.GetCStr());
410   if (!handle) {
411     return;
412   }
413   CFX_ByteString filename;
414   FX_BOOL bFolder = FALSE;
415   while (FX_GetNextFile(handle, filename, bFolder)) {
416     if (bFolder) {
417       if (filename == FX_BSTRC(".") || filename == FX_BSTRC("..")) {
418         continue;
419       }
420     } else {
421       CFX_ByteString ext = filename.Right(4);
422       ext.MakeLower();
423       if (ext != FX_BSTRC(".ttf") && ext != FX_BSTRC(".ttc")) {
424         continue;
425       }
426     }
427     CFX_ByteString fullpath = path;
428     fullpath += "/";
429     fullpath += filename;
430     if (bFolder) {
431       ScanPath(fullpath);
432     } else {
433       ScanFile(fullpath);
434     }
435   }
436   FX_CloseFolder(handle);
437 }
438 void CFPF_SkiaFontMgr::ScanFile(const CFX_ByteStringC& file) {
439   FXFT_Face face = GetFontFace(file);
440   if (face) {
441     CFPF_SkiaPathFont* pFontDesc = new CFPF_SkiaPathFont;
442     pFontDesc->SetPath(file.GetCStr());
443     ReportFace(face, pFontDesc);
444     m_FontFaces.Add(pFontDesc);
445     FXFT_Done_Face(face);
446   }
447 }
448 static const FX_DWORD g_FPFSkiaFontCharsets[] = {
449     FPF_SKIACHARSET_Ansi,
450     FPF_SKIACHARSET_EeasternEuropean,
451     FPF_SKIACHARSET_Cyrillic,
452     FPF_SKIACHARSET_Greek,
453     FPF_SKIACHARSET_Turkish,
454     FPF_SKIACHARSET_Hebrew,
455     FPF_SKIACHARSET_Arabic,
456     FPF_SKIACHARSET_Baltic,
457     0,
458     0,
459     0,
460     0,
461     0,
462     0,
463     0,
464     0,
465     FPF_SKIACHARSET_Thai,
466     FPF_SKIACHARSET_ShiftJIS,
467     FPF_SKIACHARSET_GB2312,
468     FPF_SKIACHARSET_Korean,
469     FPF_SKIACHARSET_BIG5,
470     FPF_SKIACHARSET_Johab,
471     0,
472     0,
473     0,
474     0,
475     0,
476     0,
477     0,
478     0,
479     FPF_SKIACHARSET_OEM,
480     FPF_SKIACHARSET_Symbol,
481 };
482 static FX_DWORD FPF_SkiaGetFaceCharset(TT_OS2* pOS2) {
483   FX_DWORD dwCharset = 0;
484   if (pOS2) {
485     for (int32_t i = 0; i < 32; i++) {
486       if (pOS2->ulCodePageRange1 & (1 << i)) {
487         dwCharset |= g_FPFSkiaFontCharsets[i];
488       }
489     }
490   }
491   dwCharset |= FPF_SKIACHARSET_Default;
492   return dwCharset;
493 }
494 void CFPF_SkiaFontMgr::ReportFace(FXFT_Face face,
495                                   CFPF_SkiaFontDescriptor* pFontDesc) {
496   if (!face || !pFontDesc) {
497     return;
498   }
499   pFontDesc->SetFamily(FXFT_Get_Face_Family_Name(face));
500   if (FXFT_Is_Face_Bold(face)) {
501     pFontDesc->m_dwStyle |= FXFONT_BOLD;
502   }
503   if (FXFT_Is_Face_Italic(face)) {
504     pFontDesc->m_dwStyle |= FXFONT_ITALIC;
505   }
506   if (FT_IS_FIXED_WIDTH(face)) {
507     pFontDesc->m_dwStyle |= FXFONT_FIXED_PITCH;
508   }
509   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2);
510   if (pOS2) {
511     if (pOS2->ulCodePageRange1 & (1 << 31)) {
512       pFontDesc->m_dwStyle |= FXFONT_SYMBOLIC;
513     }
514     if (pOS2->panose[0] == 2) {
515       uint8_t uSerif = pOS2->panose[1];
516       if ((uSerif > 1 && uSerif < 10) || uSerif > 13) {
517         pFontDesc->m_dwStyle |= FXFONT_SERIF;
518       }
519     }
520   }
521   if (pOS2 && (pOS2->ulCodePageRange1 & (1 << 31))) {
522     pFontDesc->m_dwStyle |= FXFONT_SYMBOLIC;
523   }
524   pFontDesc->m_dwCharsets = FPF_SkiaGetFaceCharset(pOS2);
525   pFontDesc->m_iFaceIndex = face->face_index;
526   pFontDesc->m_iGlyphNum = face->num_glyphs;
527 }
528 void CFPF_SkiaFontMgr::OutputSystemFonts() {}
529 #endif