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