Extern in .cpp file is a code smell, part 2.
[pdfium.git] / core / src / fxge / ge / fx_ge_fontmap.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 <limits>
8
9 #include "../../../include/fxge/fx_ge.h"
10 #include "../../../include/fxge/fx_freetype.h"
11 #include "../fontdata/chromefontdata/chromefontdata.h"
12 #include "text_int.h"
13
14 #define GET_TT_SHORT(w) (FX_WORD)(((w)[0] << 8) | (w)[1])
15 #define GET_TT_LONG(w) \
16   (FX_DWORD)(((w)[0] << 24) | ((w)[1] << 16) | ((w)[2] << 8) | (w)[3])
17
18 namespace {
19
20 CFX_ByteString KeyNameFromFace(const CFX_ByteString& face_name,
21                                int weight,
22                                FX_BOOL bItalic) {
23   CFX_ByteString key(face_name);
24   key += ',';
25   key += CFX_ByteString::FormatInteger(weight);
26   key += bItalic ? 'I' : 'N';
27   return key;
28 }
29
30 CFX_ByteString KeyNameFromSize(int ttc_size, FX_DWORD checksum) {
31   CFX_ByteString key;
32   key.Format("%d:%d", ttc_size, checksum);
33   return key;
34 }
35
36 }  // namespace
37
38 CFX_SubstFont::CFX_SubstFont() {
39   m_ExtHandle = NULL;
40   m_Charset = 0;
41   m_SubstFlags = 0;
42   m_Weight = 0;
43   m_ItalicAngle = 0;
44   m_bSubstOfCJK = FALSE;
45   m_WeightCJK = 0;
46   m_bItlicCJK = FALSE;
47 }
48 CTTFontDesc::~CTTFontDesc() {
49   if (m_Type == 1) {
50     if (m_SingleFace.m_pFace) {
51       FXFT_Done_Face(m_SingleFace.m_pFace);
52     }
53   } else if (m_Type == 2) {
54     for (int i = 0; i < 16; i++)
55       if (m_TTCFace.m_pFaces[i]) {
56         FXFT_Done_Face(m_TTCFace.m_pFaces[i]);
57       }
58   }
59   FX_Free(m_pFontData);
60 }
61 FX_BOOL CTTFontDesc::ReleaseFace(FXFT_Face face) {
62   if (m_Type == 1) {
63     if (m_SingleFace.m_pFace != face) {
64       return FALSE;
65     }
66   } else if (m_Type == 2) {
67     int i;
68     for (i = 0; i < 16; i++)
69       if (m_TTCFace.m_pFaces[i] == face) {
70         break;
71       }
72     if (i == 16) {
73       return FALSE;
74     }
75   }
76   m_RefCount--;
77   if (m_RefCount) {
78     return FALSE;
79   }
80   delete this;
81   return TRUE;
82 }
83 CFX_FontMgr::CFX_FontMgr() : m_FTLibrary(nullptr) {
84   m_pBuiltinMapper = new CFX_FontMapper(this);
85   FXSYS_memset(m_ExternalFonts, 0, sizeof m_ExternalFonts);
86 }
87 CFX_FontMgr::~CFX_FontMgr() {
88   delete m_pBuiltinMapper;
89   FreeCache();
90   if (m_FTLibrary) {
91     FXFT_Done_FreeType(m_FTLibrary);
92   }
93 }
94 void CFX_FontMgr::InitFTLibrary() {
95   if (m_FTLibrary == NULL) {
96     FXFT_Init_FreeType(&m_FTLibrary);
97   }
98 }
99 void CFX_FontMgr::FreeCache() {
100   for (const auto& pair : m_FaceMap) {
101     delete pair.second;
102   }
103   m_FaceMap.clear();
104 }
105 void CFX_FontMgr::SetSystemFontInfo(IFX_SystemFontInfo* pFontInfo) {
106   m_pBuiltinMapper->SetSystemFontInfo(pFontInfo);
107 }
108 FXFT_Face CFX_FontMgr::FindSubstFont(const CFX_ByteString& face_name,
109                                      FX_BOOL bTrueType,
110                                      FX_DWORD flags,
111                                      int weight,
112                                      int italic_angle,
113                                      int CharsetCP,
114                                      CFX_SubstFont* pSubstFont) {
115   if (!m_FTLibrary) {
116     FXFT_Init_FreeType(&m_FTLibrary);
117   }
118   return m_pBuiltinMapper->FindSubstFont(face_name, bTrueType, flags, weight,
119                                          italic_angle, CharsetCP, pSubstFont);
120 }
121 FXFT_Face CFX_FontMgr::GetCachedFace(const CFX_ByteString& face_name,
122                                      int weight,
123                                      FX_BOOL bItalic,
124                                      uint8_t*& pFontData) {
125   auto it = m_FaceMap.find(KeyNameFromFace(face_name, weight, bItalic));
126   if (it == m_FaceMap.end())
127     return nullptr;
128
129   CTTFontDesc* pFontDesc = it->second;
130   pFontData = pFontDesc->m_pFontData;
131   pFontDesc->m_RefCount++;
132   return pFontDesc->m_SingleFace.m_pFace;
133 }
134 FXFT_Face CFX_FontMgr::AddCachedFace(const CFX_ByteString& face_name,
135                                      int weight,
136                                      FX_BOOL bItalic,
137                                      uint8_t* pData,
138                                      FX_DWORD size,
139                                      int face_index) {
140   CTTFontDesc* pFontDesc = new CTTFontDesc;
141   pFontDesc->m_Type = 1;
142   pFontDesc->m_SingleFace.m_pFace = NULL;
143   pFontDesc->m_SingleFace.m_bBold = weight;
144   pFontDesc->m_SingleFace.m_bItalic = bItalic;
145   pFontDesc->m_pFontData = pData;
146   pFontDesc->m_RefCount = 1;
147   FXFT_Library library;
148   if (m_FTLibrary == NULL) {
149     FXFT_Init_FreeType(&m_FTLibrary);
150   }
151   library = m_FTLibrary;
152   int ret = FXFT_New_Memory_Face(library, pData, size, face_index,
153                                  &pFontDesc->m_SingleFace.m_pFace);
154   if (ret) {
155     delete pFontDesc;
156     return NULL;
157   }
158   ret = FXFT_Set_Pixel_Sizes(pFontDesc->m_SingleFace.m_pFace, 64, 64);
159   if (ret) {
160     delete pFontDesc;
161     return NULL;
162   }
163   m_FaceMap[KeyNameFromFace(face_name, weight, bItalic)] = pFontDesc;
164   return pFontDesc->m_SingleFace.m_pFace;
165 }
166 const FX_CHAR* const g_Base14FontNames[14] = {
167     "Courier",
168     "Courier-Bold",
169     "Courier-BoldOblique",
170     "Courier-Oblique",
171     "Helvetica",
172     "Helvetica-Bold",
173     "Helvetica-BoldOblique",
174     "Helvetica-Oblique",
175     "Times-Roman",
176     "Times-Bold",
177     "Times-BoldItalic",
178     "Times-Italic",
179     "Symbol",
180     "ZapfDingbats",
181 };
182 const struct _AltFontName {
183   const FX_CHAR* m_pName;
184   int m_Index;
185 } g_AltFontNames[] = {
186     {"Arial", 4},
187     {"Arial,Bold", 5},
188     {"Arial,BoldItalic", 6},
189     {"Arial,Italic", 7},
190     {"Arial-Bold", 5},
191     {"Arial-BoldItalic", 6},
192     {"Arial-BoldItalicMT", 6},
193     {"Arial-BoldMT", 5},
194     {"Arial-Italic", 7},
195     {"Arial-ItalicMT", 7},
196     {"ArialBold", 5},
197     {"ArialBoldItalic", 6},
198     {"ArialItalic", 7},
199     {"ArialMT", 4},
200     {"ArialMT,Bold", 5},
201     {"ArialMT,BoldItalic", 6},
202     {"ArialMT,Italic", 7},
203     {"ArialRoundedMTBold", 5},
204     {"Courier", 0},
205     {"Courier,Bold", 1},
206     {"Courier,BoldItalic", 2},
207     {"Courier,Italic", 3},
208     {"Courier-Bold", 1},
209     {"Courier-BoldOblique", 2},
210     {"Courier-Oblique", 3},
211     {"CourierBold", 1},
212     {"CourierBoldItalic", 2},
213     {"CourierItalic", 3},
214     {"CourierNew", 0},
215     {"CourierNew,Bold", 1},
216     {"CourierNew,BoldItalic", 2},
217     {"CourierNew,Italic", 3},
218     {"CourierNew-Bold", 1},
219     {"CourierNew-BoldItalic", 2},
220     {"CourierNew-Italic", 3},
221     {"CourierNewBold", 1},
222     {"CourierNewBoldItalic", 2},
223     {"CourierNewItalic", 3},
224     {"CourierNewPS-BoldItalicMT", 2},
225     {"CourierNewPS-BoldMT", 1},
226     {"CourierNewPS-ItalicMT", 3},
227     {"CourierNewPSMT", 0},
228     {"CourierStd", 0},
229     {"CourierStd-Bold", 1},
230     {"CourierStd-BoldOblique", 2},
231     {"CourierStd-Oblique", 3},
232     {"Helvetica", 4},
233     {"Helvetica,Bold", 5},
234     {"Helvetica,BoldItalic", 6},
235     {"Helvetica,Italic", 7},
236     {"Helvetica-Bold", 5},
237     {"Helvetica-BoldItalic", 6},
238     {"Helvetica-BoldOblique", 6},
239     {"Helvetica-Italic", 7},
240     {"Helvetica-Oblique", 7},
241     {"HelveticaBold", 5},
242     {"HelveticaBoldItalic", 6},
243     {"HelveticaItalic", 7},
244     {"Symbol", 12},
245     {"SymbolMT", 12},
246     {"Times-Bold", 9},
247     {"Times-BoldItalic", 10},
248     {"Times-Italic", 11},
249     {"Times-Roman", 8},
250     {"TimesBold", 9},
251     {"TimesBoldItalic", 10},
252     {"TimesItalic", 11},
253     {"TimesNewRoman", 8},
254     {"TimesNewRoman,Bold", 9},
255     {"TimesNewRoman,BoldItalic", 10},
256     {"TimesNewRoman,Italic", 11},
257     {"TimesNewRoman-Bold", 9},
258     {"TimesNewRoman-BoldItalic", 10},
259     {"TimesNewRoman-Italic", 11},
260     {"TimesNewRomanBold", 9},
261     {"TimesNewRomanBoldItalic", 10},
262     {"TimesNewRomanItalic", 11},
263     {"TimesNewRomanPS", 8},
264     {"TimesNewRomanPS-Bold", 9},
265     {"TimesNewRomanPS-BoldItalic", 10},
266     {"TimesNewRomanPS-BoldItalicMT", 10},
267     {"TimesNewRomanPS-BoldMT", 9},
268     {"TimesNewRomanPS-Italic", 11},
269     {"TimesNewRomanPS-ItalicMT", 11},
270     {"TimesNewRomanPSMT", 8},
271     {"TimesNewRomanPSMT,Bold", 9},
272     {"TimesNewRomanPSMT,BoldItalic", 10},
273     {"TimesNewRomanPSMT,Italic", 11},
274     {"ZapfDingbats", 13},
275 };
276 extern "C" {
277 static int compareString(const void* key, const void* element) {
278   return FXSYS_stricmp((const FX_CHAR*)key, ((_AltFontName*)element)->m_pName);
279 }
280 }
281 int _PDF_GetStandardFontName(CFX_ByteString& name) {
282   _AltFontName* found =
283       (_AltFontName*)FXSYS_bsearch(name.c_str(), g_AltFontNames,
284                                    sizeof g_AltFontNames / sizeof(_AltFontName),
285                                    sizeof(_AltFontName), compareString);
286   if (found == NULL) {
287     return -1;
288   }
289   name = g_Base14FontNames[found->m_Index];
290   return found->m_Index;
291 }
292 int GetTTCIndex(const uint8_t* pFontData,
293                 FX_DWORD ttc_size,
294                 FX_DWORD font_offset) {
295   int face_index = 0;
296   const uint8_t* p = pFontData + 8;
297   FX_DWORD nfont = GET_TT_LONG(p);
298   FX_DWORD index;
299   for (index = 0; index < nfont; index++) {
300     p = pFontData + 12 + index * 4;
301     if (GET_TT_LONG(p) == font_offset) {
302       break;
303     }
304   }
305   if (index >= nfont) {
306     face_index = 0;
307   } else {
308     face_index = index;
309   }
310   return face_index;
311 }
312 FXFT_Face CFX_FontMgr::GetCachedTTCFace(int ttc_size,
313                                         FX_DWORD checksum,
314                                         int font_offset,
315                                         uint8_t*& pFontData) {
316   auto it = m_FaceMap.find(KeyNameFromSize(ttc_size, checksum));
317   if (it == m_FaceMap.end())
318     return nullptr;
319
320   CTTFontDesc* pFontDesc = it->second;
321   pFontData = pFontDesc->m_pFontData;
322   pFontDesc->m_RefCount++;
323   int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
324   if (!pFontDesc->m_TTCFace.m_pFaces[face_index]) {
325     pFontDesc->m_TTCFace.m_pFaces[face_index] =
326         GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
327   }
328   return pFontDesc->m_TTCFace.m_pFaces[face_index];
329 }
330 FXFT_Face CFX_FontMgr::AddCachedTTCFace(int ttc_size,
331                                         FX_DWORD checksum,
332                                         uint8_t* pData,
333                                         FX_DWORD size,
334                                         int font_offset) {
335   CTTFontDesc* pFontDesc = new CTTFontDesc;
336   pFontDesc->m_Type = 2;
337   pFontDesc->m_pFontData = pData;
338   for (int i = 0; i < 16; i++) {
339     pFontDesc->m_TTCFace.m_pFaces[i] = NULL;
340   }
341   pFontDesc->m_RefCount++;
342   m_FaceMap[KeyNameFromSize(ttc_size, checksum)] = pFontDesc;
343   int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
344   pFontDesc->m_TTCFace.m_pFaces[face_index] =
345       GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
346   return pFontDesc->m_TTCFace.m_pFaces[face_index];
347 }
348 FXFT_Face CFX_FontMgr::GetFixedFace(const uint8_t* pData,
349                                     FX_DWORD size,
350                                     int face_index) {
351   FXFT_Library library;
352   if (m_FTLibrary == NULL) {
353     FXFT_Init_FreeType(&m_FTLibrary);
354   }
355   library = m_FTLibrary;
356   FXFT_Face face = NULL;
357   int ret = FXFT_New_Memory_Face(library, pData, size, face_index, &face);
358   if (ret) {
359     return NULL;
360   }
361   ret = FXFT_Set_Pixel_Sizes(face, 64, 64);
362   if (ret) {
363     return NULL;
364   }
365   return face;
366 }
367 FXFT_Face CFX_FontMgr::GetFileFace(const FX_CHAR* filename, int face_index) {
368   FXFT_Library library;
369   if (m_FTLibrary == NULL) {
370     FXFT_Init_FreeType(&m_FTLibrary);
371   }
372   library = m_FTLibrary;
373   FXFT_Face face = NULL;
374   int ret = FXFT_New_Face(library, filename, face_index, &face);
375   if (ret) {
376     return NULL;
377   }
378   ret = FXFT_Set_Pixel_Sizes(face, 64, 64);
379   if (ret) {
380     return NULL;
381   }
382   return face;
383 }
384 void CFX_FontMgr::ReleaseFace(FXFT_Face face) {
385   if (!face) {
386     return;
387   }
388   auto it = m_FaceMap.begin();
389   while (it != m_FaceMap.end()) {
390     auto temp = it++;
391     if (temp->second->ReleaseFace(face)) {
392       m_FaceMap.erase(temp);
393     }
394   }
395 }
396 const FoxitFonts g_FoxitFonts[14] = {
397     {g_FoxitFixedFontData, 17597},
398     {g_FoxitFixedBoldFontData, 18055},
399     {g_FoxitFixedBoldItalicFontData, 19151},
400     {g_FoxitFixedItalicFontData, 18746},
401     {g_FoxitSansFontData, 15025},
402     {g_FoxitSansBoldFontData, 16344},
403     {g_FoxitSansBoldItalicFontData, 16418},
404     {g_FoxitSansItalicFontData, 16339},
405     {g_FoxitSerifFontData, 19469},
406     {g_FoxitSerifBoldFontData, 19395},
407     {g_FoxitSerifBoldItalicFontData, 20733},
408     {g_FoxitSerifItalicFontData, 21227},
409     {g_FoxitSymbolFontData, 16729},
410     {g_FoxitDingbatsFontData, 29513},
411 };
412 FX_BOOL CFX_FontMgr::GetStandardFont(const uint8_t*& pFontData,
413                                      FX_DWORD& size,
414                                      int index) {
415   if (index > 15 || index < 0) {
416     return FALSE;
417   }
418   {
419     if (index >= 14) {
420       if (index == 14) {
421         pFontData = g_FoxitSerifMMFontData;
422         size = 113417;
423       } else {
424         pFontData = g_FoxitSansMMFontData;
425         size = 66919;
426       }
427     } else {
428       pFontData = g_FoxitFonts[index].m_pFontData;
429       size = g_FoxitFonts[index].m_dwSize;
430     }
431   }
432   return TRUE;
433 }
434 CFX_FontMapper::CFX_FontMapper(CFX_FontMgr* mgr)
435     : m_bListLoaded(FALSE),
436       m_pFontInfo(nullptr),
437       m_pFontEnumerator(nullptr),
438       m_pFontMgr(mgr) {
439   m_MMFaces[0] = nullptr;
440   m_MMFaces[1] = nullptr;
441   FXSYS_memset(m_FoxitFaces, 0, sizeof(m_FoxitFaces));
442 }
443 CFX_FontMapper::~CFX_FontMapper() {
444   for (int i = 0; i < 14; i++)
445     if (m_FoxitFaces[i]) {
446       FXFT_Done_Face(m_FoxitFaces[i]);
447     }
448   if (m_MMFaces[0]) {
449     FXFT_Done_Face(m_MMFaces[0]);
450   }
451   if (m_MMFaces[1]) {
452     FXFT_Done_Face(m_MMFaces[1]);
453   }
454   if (m_pFontInfo) {
455     m_pFontInfo->Release();
456   }
457 }
458 void CFX_FontMapper::SetSystemFontInfo(IFX_SystemFontInfo* pFontInfo) {
459   if (pFontInfo == NULL) {
460     return;
461   }
462   if (m_pFontInfo) {
463     m_pFontInfo->Release();
464   }
465   m_pFontInfo = pFontInfo;
466 }
467 static CFX_ByteString _TT_NormalizeName(const FX_CHAR* family) {
468   CFX_ByteString norm(family, -1);
469   norm.Remove(' ');
470   norm.Remove('-');
471   norm.Remove(',');
472   int pos = norm.Find('+');
473   if (pos > 0) {
474     norm = norm.Left(pos);
475   }
476   norm.MakeLower();
477   return norm;
478 }
479 CFX_ByteString GetNameFromTT(const uint8_t* name_table, FX_DWORD name_id) {
480   const uint8_t* ptr = name_table + 2;
481   int name_count = GET_TT_SHORT(ptr);
482   int string_offset = GET_TT_SHORT(ptr + 2);
483   const uint8_t* string_ptr = name_table + string_offset;
484   ptr += 4;
485   for (int i = 0; i < name_count; i++) {
486     if (GET_TT_SHORT(ptr + 6) == name_id && GET_TT_SHORT(ptr) == 1 &&
487         GET_TT_SHORT(ptr + 2) == 0) {
488       return CFX_ByteStringC(string_ptr + GET_TT_SHORT(ptr + 10),
489                              GET_TT_SHORT(ptr + 8));
490     }
491     ptr += 12;
492   }
493   return CFX_ByteString();
494 }
495 static CFX_ByteString _FPDF_ReadStringFromFile(FXSYS_FILE* pFile,
496                                                FX_DWORD size) {
497   CFX_ByteString buffer;
498   if (!FXSYS_fread(buffer.GetBuffer(size), size, 1, pFile)) {
499     return CFX_ByteString();
500   }
501   buffer.ReleaseBuffer(size);
502   return buffer;
503 }
504 CFX_ByteString _FPDF_LoadTableFromTT(FXSYS_FILE* pFile,
505                                      const uint8_t* pTables,
506                                      FX_DWORD nTables,
507                                      FX_DWORD tag) {
508   for (FX_DWORD i = 0; i < nTables; i++) {
509     const uint8_t* p = pTables + i * 16;
510     if (GET_TT_LONG(p) == tag) {
511       FX_DWORD offset = GET_TT_LONG(p + 8);
512       FX_DWORD size = GET_TT_LONG(p + 12);
513       FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
514       return _FPDF_ReadStringFromFile(pFile, size);
515     }
516   }
517   return CFX_ByteString();
518 }
519 CFX_ByteString _FPDF_LoadTableFromTTStreamFile(IFX_FileStream* pFile,
520                                                const uint8_t* pTables,
521                                                FX_DWORD nTables,
522                                                FX_DWORD tag) {
523   for (FX_DWORD i = 0; i < nTables; i++) {
524     const uint8_t* p = pTables + i * 16;
525     if (GET_TT_LONG(p) == tag) {
526       FX_DWORD offset = GET_TT_LONG(p + 8);
527       FX_DWORD size = GET_TT_LONG(p + 12);
528       CFX_ByteString buffer;
529       if (!pFile->ReadBlock(buffer.GetBuffer(size), offset, size)) {
530         return CFX_ByteString();
531       }
532       buffer.ReleaseBuffer(size);
533       return buffer;
534     }
535   }
536   return CFX_ByteString();
537 }
538 CFX_ByteString CFX_FontMapper::GetPSNameFromTT(void* hFont) {
539   if (m_pFontInfo == NULL) {
540     CFX_ByteString();
541   }
542   CFX_ByteString result;
543   FX_DWORD size = m_pFontInfo->GetFontData(hFont, 0x6e616d65, NULL, 0);
544   if (size) {
545     uint8_t* buffer = FX_Alloc(uint8_t, size);
546     m_pFontInfo->GetFontData(hFont, 0x6e616d65, buffer, size);
547     result = GetNameFromTT(buffer, 6);
548     FX_Free(buffer);
549   }
550   return result;
551 }
552 void CFX_FontMapper::AddInstalledFont(const CFX_ByteString& name, int charset) {
553   if (m_pFontInfo == NULL) {
554     return;
555   }
556   if (m_CharsetArray.Find((FX_DWORD)charset) == -1) {
557     m_CharsetArray.Add((FX_DWORD)charset);
558     m_FaceArray.Add(name);
559   }
560   if (name == m_LastFamily) {
561     return;
562   }
563   const uint8_t* ptr = name;
564   FX_BOOL bLocalized = FALSE;
565   for (int i = 0; i < name.GetLength(); i++)
566     if (ptr[i] > 0x80) {
567       bLocalized = TRUE;
568       break;
569     }
570   if (bLocalized) {
571     void* hFont = m_pFontInfo->GetFont(name);
572     if (hFont == NULL) {
573       int iExact;
574       hFont =
575           m_pFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0, name, iExact);
576       if (hFont == NULL) {
577         return;
578       }
579     }
580     CFX_ByteString new_name = GetPSNameFromTT(hFont);
581     if (!new_name.IsEmpty()) {
582       new_name.Insert(0, ' ');
583       m_InstalledTTFonts.Add(new_name);
584     }
585     m_pFontInfo->DeleteFont(hFont);
586   }
587   m_InstalledTTFonts.Add(name);
588   m_LastFamily = name;
589 }
590 void CFX_FontMapper::LoadInstalledFonts() {
591   if (m_pFontInfo == NULL) {
592     return;
593   }
594   if (m_bListLoaded) {
595     return;
596   }
597   if (m_bListLoaded) {
598     return;
599   }
600   m_pFontInfo->EnumFontList(this);
601   m_bListLoaded = TRUE;
602 }
603 CFX_ByteString CFX_FontMapper::MatchInstalledFonts(
604     const CFX_ByteString& norm_name) {
605   LoadInstalledFonts();
606   int i;
607   for (i = m_InstalledTTFonts.GetSize() - 1; i >= 0; i--) {
608     CFX_ByteString norm1 = _TT_NormalizeName(m_InstalledTTFonts[i]);
609     if (norm1 == norm_name) {
610       break;
611     }
612   }
613   if (i < 0) {
614     return CFX_ByteString();
615   }
616   CFX_ByteString match = m_InstalledTTFonts[i];
617   if (match[0] == ' ') {
618     match = m_InstalledTTFonts[i + 1];
619   }
620   return match;
621 }
622 typedef struct _CHARSET_MAP_ {
623   uint8_t charset;
624   FX_WORD codepage;
625 } CHARSET_MAP;
626 static const CHARSET_MAP g_Codepage2CharsetTable[] = {
627     {1, 0},      {2, 42},     {254, 437},  {255, 850},  {222, 874},
628     {128, 932},  {134, 936},  {129, 949},  {136, 950},  {238, 1250},
629     {204, 1251}, {0, 1252},   {161, 1253}, {162, 1254}, {177, 1255},
630     {178, 1256}, {186, 1257}, {163, 1258}, {130, 1361}, {77, 10000},
631     {78, 10001}, {79, 10003}, {80, 10008}, {81, 10002}, {83, 10005},
632     {84, 10004}, {85, 10006}, {86, 10081}, {87, 10021}, {88, 10029},
633     {89, 10007},
634 };
635 uint8_t _GetCharsetFromCodePage(FX_WORD codepage) {
636   int32_t iEnd = sizeof(g_Codepage2CharsetTable) / sizeof(CHARSET_MAP) - 1;
637   FXSYS_assert(iEnd >= 0);
638   int32_t iStart = 0, iMid;
639   do {
640     iMid = (iStart + iEnd) / 2;
641     const CHARSET_MAP& cp = g_Codepage2CharsetTable[iMid];
642     if (codepage == cp.codepage) {
643       return cp.charset;
644     }
645     if (codepage < cp.codepage) {
646       iEnd = iMid - 1;
647     } else {
648       iStart = iMid + 1;
649     }
650   } while (iStart <= iEnd);
651   return 1;
652 }
653 FX_DWORD _GetCodePageRangeFromCharset(int charset) {
654   if (charset == FXFONT_EASTEUROPE_CHARSET) {
655     return 1 << 1;
656   }
657   if (charset == FXFONT_GREEK_CHARSET) {
658     return 1 << 3;
659   }
660   if (charset == FXFONT_TURKISH_CHARSET) {
661     return 1 << 4;
662   }
663   if (charset == FXFONT_HEBREW_CHARSET) {
664     return 1 << 5;
665   }
666   if (charset == FXFONT_ARABIC_CHARSET) {
667     return 1 << 6;
668   }
669   if (charset == FXFONT_BALTIC_CHARSET) {
670     return 1 << 7;
671   }
672   if (charset == FXFONT_THAI_CHARSET) {
673     return 1 << 16;
674   }
675   if (charset == FXFONT_SHIFTJIS_CHARSET) {
676     return 1 << 17;
677   }
678   if (charset == FXFONT_GB2312_CHARSET) {
679     return 1 << 18;
680   }
681   if (charset == FXFONT_CHINESEBIG5_CHARSET) {
682     return 1 << 20;
683   }
684   if (charset == FXFONT_HANGEUL_CHARSET) {
685     return 1 << 19;
686   }
687   if (charset == FXFONT_SYMBOL_CHARSET) {
688     return 1 << 31;
689   }
690   return 1 << 21;
691 }
692 FXFT_Face CFX_FontMapper::UseInternalSubst(CFX_SubstFont* pSubstFont,
693                                            int iBaseFont,
694                                            int italic_angle,
695                                            int weight,
696                                            int picthfamily) {
697   if (iBaseFont < 12) {
698     if (m_FoxitFaces[iBaseFont]) {
699       return m_FoxitFaces[iBaseFont];
700     }
701     const uint8_t* pFontData = NULL;
702     FX_DWORD size = 0;
703     if (m_pFontMgr->GetStandardFont(pFontData, size, iBaseFont)) {
704       m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
705       return m_FoxitFaces[iBaseFont];
706     }
707   }
708   pSubstFont->m_SubstFlags |= FXFONT_SUBST_MM;
709   pSubstFont->m_ItalicAngle = italic_angle;
710   if (weight) {
711     pSubstFont->m_Weight = weight;
712   }
713   if (picthfamily & FXFONT_FF_ROMAN) {
714     pSubstFont->m_Weight = pSubstFont->m_Weight * 4 / 5;
715     pSubstFont->m_Family = "Chrome Serif";
716     if (m_MMFaces[1]) {
717       return m_MMFaces[1];
718     }
719     const uint8_t* pFontData = NULL;
720     FX_DWORD size;
721     m_pFontMgr->GetStandardFont(pFontData, size, 14);
722     m_MMFaces[1] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
723     return m_MMFaces[1];
724   }
725   pSubstFont->m_Family = "Chrome Sans";
726   if (m_MMFaces[0]) {
727     return m_MMFaces[0];
728   }
729   const uint8_t* pFontData = NULL;
730   FX_DWORD size = 0;
731   m_pFontMgr->GetStandardFont(pFontData, size, 15);
732   m_MMFaces[0] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
733   return m_MMFaces[0];
734 }
735 const struct _AltFontFamily {
736   const FX_CHAR* m_pFontName;
737   const FX_CHAR* m_pFontFamily;
738 } g_AltFontFamilies[] = {
739     {"AGaramondPro", "Adobe Garamond Pro"},
740     {"BankGothicBT-Medium", "BankGothic Md BT"},
741     {"ForteMT", "Forte"},
742 };
743 extern "C" {
744 static int compareFontFamilyString(const void* key, const void* element) {
745   CFX_ByteString str_key((const FX_CHAR*)key);
746   if (str_key.Find(((_AltFontFamily*)element)->m_pFontName) != -1) {
747     return 0;
748   }
749   return FXSYS_stricmp((const FX_CHAR*)key,
750                        ((_AltFontFamily*)element)->m_pFontName);
751 }
752 }
753 #define FX_FONT_STYLE_None 0x00
754 #define FX_FONT_STYLE_Bold 0x01
755 #define FX_FONT_STYLE_Italic 0x02
756 #define FX_FONT_STYLE_BoldBold 0x04
757 static CFX_ByteString _GetFontFamily(CFX_ByteString fontName, int nStyle) {
758   if (fontName.Find("Script") >= 0) {
759     if ((nStyle & FX_FONT_STYLE_Bold) == FX_FONT_STYLE_Bold) {
760       fontName = "ScriptMTBold";
761     } else if (fontName.Find("Palace") >= 0) {
762       fontName = "PalaceScriptMT";
763     } else if (fontName.Find("French") >= 0) {
764       fontName = "FrenchScriptMT";
765     } else if (fontName.Find("FreeStyle") >= 0) {
766       fontName = "FreeStyleScript";
767     }
768     return fontName;
769   }
770   _AltFontFamily* found = (_AltFontFamily*)FXSYS_bsearch(
771       fontName.c_str(), g_AltFontFamilies,
772       sizeof g_AltFontFamilies / sizeof(_AltFontFamily), sizeof(_AltFontFamily),
773       compareFontFamilyString);
774   if (found == NULL) {
775     return fontName;
776   }
777   return found->m_pFontFamily;
778 };
779 typedef struct _FX_FontStyle {
780   const FX_CHAR* style;
781   int32_t len;
782 } FX_FontStyle;
783 const FX_FontStyle g_FontStyles[] = {
784     {"Bold", 4}, {"Italic", 6}, {"BoldItalic", 10}, {"Reg", 3}, {"Regular", 7},
785 };
786 CFX_ByteString ParseStyle(const FX_CHAR* pStyle, int iLen, int iIndex) {
787   CFX_ByteTextBuf buf;
788   if (!iLen || iLen <= iIndex) {
789     return buf.GetByteString();
790   }
791   while (iIndex < iLen) {
792     if (pStyle[iIndex] == ',') {
793       break;
794     }
795     buf.AppendChar(pStyle[iIndex]);
796     ++iIndex;
797   }
798   return buf.GetByteString();
799 }
800 int32_t GetStyleType(const CFX_ByteString& bsStyle, FX_BOOL bRevert) {
801   int32_t iLen = bsStyle.GetLength();
802   if (!iLen) {
803     return -1;
804   }
805   int iSize = sizeof(g_FontStyles) / sizeof(FX_FontStyle);
806   const FX_FontStyle* pStyle = NULL;
807   for (int i = iSize - 1; i >= 0; --i) {
808     pStyle = g_FontStyles + i;
809     if (!pStyle || pStyle->len > iLen) {
810       continue;
811     }
812     if (!bRevert) {
813       if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0) {
814         return i;
815       }
816     } else {
817       if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0) {
818         return i;
819       }
820     }
821   }
822   return -1;
823 }
824 FX_BOOL CheckSupportThirdPartFont(CFX_ByteString name, int& PitchFamily) {
825   if (name == FX_BSTRC("MyriadPro")) {
826     PitchFamily &= ~FXFONT_FF_ROMAN;
827     return TRUE;
828   }
829   return FALSE;
830 }
831 FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name,
832                                         FX_BOOL bTrueType,
833                                         FX_DWORD flags,
834                                         int weight,
835                                         int italic_angle,
836                                         int WindowCP,
837                                         CFX_SubstFont* pSubstFont) {
838   if (!(flags & FXFONT_USEEXTERNATTR)) {
839     weight = FXFONT_FW_NORMAL;
840     italic_angle = 0;
841   }
842   CFX_ByteString SubstName = name;
843   SubstName.Remove(0x20);
844   if (bTrueType) {
845     if (name[0] == '@') {
846       SubstName = name.Mid(1);
847     }
848   }
849   _PDF_GetStandardFontName(SubstName);
850   if (SubstName == FX_BSTRC("Symbol") && !bTrueType) {
851     pSubstFont->m_Family = "Chrome Symbol";
852     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
853     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
854     if (m_FoxitFaces[12]) {
855       return m_FoxitFaces[12];
856     }
857     const uint8_t* pFontData = NULL;
858     FX_DWORD size = 0;
859     m_pFontMgr->GetStandardFont(pFontData, size, 12);
860     m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
861     return m_FoxitFaces[12];
862   }
863   if (SubstName == FX_BSTRC("ZapfDingbats")) {
864     pSubstFont->m_Family = "Chrome Dingbats";
865     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
866     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
867     if (m_FoxitFaces[13]) {
868       return m_FoxitFaces[13];
869     }
870     const uint8_t* pFontData = NULL;
871     FX_DWORD size = 0;
872     m_pFontMgr->GetStandardFont(pFontData, size, 13);
873     m_FoxitFaces[13] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
874     return m_FoxitFaces[13];
875   }
876   int iBaseFont = 0;
877   CFX_ByteString family, style;
878   FX_BOOL bHasComma = FALSE;
879   FX_BOOL bHasHypen = FALSE;
880   int find = SubstName.Find(FX_BSTRC(","), 0);
881   if (find >= 0) {
882     family = SubstName.Left(find);
883     _PDF_GetStandardFontName(family);
884     style = SubstName.Mid(find + 1);
885     bHasComma = TRUE;
886   } else {
887     family = SubstName;
888   }
889   for (; iBaseFont < 12; iBaseFont++)
890     if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont])) {
891       break;
892     }
893   int PitchFamily = 0;
894   FX_BOOL bItalic = FALSE;
895   FX_DWORD nStyle = 0;
896   FX_BOOL bStyleAvail = FALSE;
897   if (iBaseFont < 12) {
898     family = g_Base14FontNames[iBaseFont];
899     if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2) {
900       nStyle |= FX_FONT_STYLE_Bold;
901     }
902     if ((iBaseFont % 4) / 2) {
903       nStyle |= FX_FONT_STYLE_Italic;
904     }
905     if (iBaseFont < 4) {
906       PitchFamily |= FXFONT_FF_FIXEDPITCH;
907     }
908     if (iBaseFont >= 8) {
909       PitchFamily |= FXFONT_FF_ROMAN;
910     }
911   } else {
912     if (!bHasComma) {
913       find = family.ReverseFind('-');
914       if (find >= 0) {
915         style = family.Mid(find + 1);
916         family = family.Left(find);
917         bHasHypen = TRUE;
918       }
919     }
920     if (!bHasHypen) {
921       int nLen = family.GetLength();
922       int32_t nRet = GetStyleType(family, TRUE);
923       if (nRet > -1) {
924         family = family.Left(nLen - g_FontStyles[nRet].len);
925         if (nRet == 0) {
926           nStyle |= FX_FONT_STYLE_Bold;
927         }
928         if (nRet == 1) {
929           nStyle |= FX_FONT_STYLE_Italic;
930         }
931         if (nRet == 2) {
932           nStyle |= (FX_FONT_STYLE_Bold | FX_FONT_STYLE_Italic);
933         }
934       }
935     }
936     if (flags & FXFONT_SERIF) {
937       PitchFamily |= FXFONT_FF_ROMAN;
938     }
939     if (flags & FXFONT_SCRIPT) {
940       PitchFamily |= FXFONT_FF_SCRIPT;
941     }
942     if (flags & FXFONT_FIXED_PITCH) {
943       PitchFamily |= FXFONT_FF_FIXEDPITCH;
944     }
945   }
946   if (!style.IsEmpty()) {
947     int nLen = style.GetLength();
948     const FX_CHAR* pStyle = style;
949     int i = 0;
950     FX_BOOL bFirstItem = TRUE;
951     CFX_ByteString buf;
952     while (i < nLen) {
953       buf = ParseStyle(pStyle, nLen, i);
954       int32_t nRet = GetStyleType(buf, FALSE);
955       if ((i && !bStyleAvail) || (!i && nRet < 0)) {
956         family = SubstName;
957         iBaseFont = 12;
958         break;
959       } else if (nRet >= 0) {
960         bStyleAvail = TRUE;
961       }
962       if (nRet == 0) {
963         if (nStyle & FX_FONT_STYLE_Bold) {
964           nStyle |= FX_FONT_STYLE_BoldBold;
965         } else {
966           nStyle |= FX_FONT_STYLE_Bold;
967         }
968         bFirstItem = FALSE;
969       }
970       if (nRet == 1) {
971         if (bFirstItem) {
972           nStyle |= FX_FONT_STYLE_Italic;
973         } else {
974           family = SubstName;
975           iBaseFont = 12;
976         }
977         break;
978       }
979       if (nRet == 2) {
980         nStyle |= FX_FONT_STYLE_Italic;
981         if (nStyle & FX_FONT_STYLE_Bold) {
982           nStyle |= FX_FONT_STYLE_BoldBold;
983         } else {
984           nStyle |= FX_FONT_STYLE_Bold;
985         }
986         bFirstItem = FALSE;
987       }
988       i += buf.GetLength() + 1;
989     }
990   }
991   weight = weight ? weight : FXFONT_FW_NORMAL;
992   int old_weight = weight;
993   if (nStyle) {
994     weight =
995         nStyle & FX_FONT_STYLE_BoldBold
996             ? 900
997             : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
998   }
999   if (nStyle & FX_FONT_STYLE_Italic) {
1000     bItalic = TRUE;
1001   }
1002   FX_BOOL bCJK = FALSE;
1003   int iExact = 0;
1004   int Charset = FXFONT_ANSI_CHARSET;
1005   if (WindowCP) {
1006     Charset = _GetCharsetFromCodePage(WindowCP);
1007   } else if (iBaseFont == 12 && (flags & FXFONT_SYMBOLIC)) {
1008     Charset = FXFONT_SYMBOL_CHARSET;
1009   }
1010   if (Charset == FXFONT_SHIFTJIS_CHARSET || Charset == FXFONT_GB2312_CHARSET ||
1011       Charset == FXFONT_HANGEUL_CHARSET ||
1012       Charset == FXFONT_CHINESEBIG5_CHARSET) {
1013     bCJK = TRUE;
1014   }
1015   if (m_pFontInfo == NULL) {
1016     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
1017     return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
1018                             PitchFamily);
1019   }
1020   family = _GetFontFamily(family, nStyle);
1021   CFX_ByteString match = MatchInstalledFonts(_TT_NormalizeName(family));
1022   if (match.IsEmpty() && family != SubstName &&
1023       (!bHasComma && (!bHasHypen || (bHasHypen && !bStyleAvail)))) {
1024     match = MatchInstalledFonts(_TT_NormalizeName(SubstName));
1025   }
1026   if (match.IsEmpty() && iBaseFont >= 12) {
1027     if (!bCJK) {
1028       if (!CheckSupportThirdPartFont(family, PitchFamily)) {
1029         if (italic_angle != 0) {
1030           bItalic = TRUE;
1031         } else {
1032           bItalic = FALSE;
1033         }
1034         weight = old_weight;
1035       }
1036     } else {
1037       pSubstFont->m_bSubstOfCJK = TRUE;
1038       if (nStyle) {
1039         pSubstFont->m_WeightCJK = weight;
1040       } else {
1041         pSubstFont->m_WeightCJK = FXFONT_FW_NORMAL;
1042       }
1043       if (nStyle & FX_FONT_STYLE_Italic) {
1044         pSubstFont->m_bItlicCJK = TRUE;
1045       }
1046     }
1047   } else {
1048     italic_angle = 0;
1049     weight =
1050         nStyle & FX_FONT_STYLE_BoldBold
1051             ? 900
1052             : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
1053   }
1054   if (!match.IsEmpty() || iBaseFont < 12) {
1055     pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
1056     if (!match.IsEmpty()) {
1057       family = match;
1058     }
1059     if (iBaseFont < 12) {
1060       if (nStyle && !(iBaseFont % 4)) {
1061         if ((nStyle & 0x3) == 1) {
1062           iBaseFont += 1;
1063         }
1064         if ((nStyle & 0x3) == 2) {
1065           iBaseFont += 3;
1066         }
1067         if ((nStyle & 0x3) == 3) {
1068           iBaseFont += 2;
1069         }
1070       }
1071       if (m_pFontMgr->m_ExternalFonts[iBaseFont].m_pFontData) {
1072         if (m_FoxitFaces[iBaseFont]) {
1073           return m_FoxitFaces[iBaseFont];
1074         }
1075         m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(
1076             m_pFontMgr->m_ExternalFonts[iBaseFont].m_pFontData,
1077             m_pFontMgr->m_ExternalFonts[iBaseFont].m_dwSize, 0);
1078         if (m_FoxitFaces[iBaseFont]) {
1079           return m_FoxitFaces[iBaseFont];
1080         }
1081       } else {
1082         family = g_Base14FontNames[iBaseFont];
1083       }
1084       pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
1085     }
1086   } else {
1087     if (flags & FXFONT_ITALIC) {
1088       bItalic = TRUE;
1089     }
1090   }
1091   iExact = !match.IsEmpty();
1092   void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily,
1093                                      family, iExact);
1094   if (iExact) {
1095     pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
1096   }
1097   if (hFont == NULL) {
1098     if (bCJK) {
1099       if (italic_angle != 0) {
1100         bItalic = TRUE;
1101       } else {
1102         bItalic = FALSE;
1103       }
1104       weight = old_weight;
1105     }
1106     if (!match.IsEmpty()) {
1107       hFont = m_pFontInfo->GetFont(match);
1108       if (hFont == NULL) {
1109         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
1110                                 PitchFamily);
1111       }
1112     } else {
1113       if (Charset == FXFONT_SYMBOL_CHARSET) {
1114 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || \
1115     _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_
1116         if (SubstName == FX_BSTRC("Symbol")) {
1117           pSubstFont->m_Family = "Chrome Symbol";
1118           pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
1119           pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
1120           if (m_FoxitFaces[12]) {
1121             return m_FoxitFaces[12];
1122           }
1123           const uint8_t* pFontData = NULL;
1124           FX_DWORD size = 0;
1125           m_pFontMgr->GetStandardFont(pFontData, size, 12);
1126           m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
1127           return m_FoxitFaces[12];
1128         }
1129 #endif
1130         pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
1131         return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC,
1132                              weight, italic_angle, 0, pSubstFont);
1133       }
1134       if (Charset == FXFONT_ANSI_CHARSET) {
1135         pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
1136         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
1137                                 PitchFamily);
1138       }
1139       int index = m_CharsetArray.Find(Charset);
1140       if (index < 0) {
1141         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
1142                                 PitchFamily);
1143       }
1144       hFont = m_pFontInfo->GetFont(m_FaceArray[index]);
1145     }
1146   }
1147   pSubstFont->m_ExtHandle = m_pFontInfo->RetainFont(hFont);
1148   if (hFont == NULL) {
1149     return NULL;
1150   }
1151   m_pFontInfo->GetFaceName(hFont, SubstName);
1152   if (Charset == FXFONT_DEFAULT_CHARSET) {
1153     m_pFontInfo->GetFontCharset(hFont, Charset);
1154   }
1155   FX_DWORD ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, NULL, 0);
1156   FX_DWORD font_size = m_pFontInfo->GetFontData(hFont, 0, NULL, 0);
1157   if (font_size == 0 && ttc_size == 0) {
1158     m_pFontInfo->DeleteFont(hFont);
1159     return NULL;
1160   }
1161   FXFT_Face face = NULL;
1162   if (ttc_size) {
1163     uint8_t temp[1024];
1164     m_pFontInfo->GetFontData(hFont, 0x74746366, temp, 1024);
1165     FX_DWORD checksum = 0;
1166     for (int i = 0; i < 256; i++) {
1167       checksum += ((FX_DWORD*)temp)[i];
1168     }
1169     uint8_t* pFontData;
1170     face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum,
1171                                         ttc_size - font_size, pFontData);
1172     if (face == NULL) {
1173       pFontData = FX_Alloc(uint8_t, ttc_size);
1174       m_pFontInfo->GetFontData(hFont, 0x74746366, pFontData, ttc_size);
1175       face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData,
1176                                           ttc_size, ttc_size - font_size);
1177     }
1178   } else {
1179     uint8_t* pFontData;
1180     face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
1181     if (face == NULL) {
1182       pFontData = FX_Alloc(uint8_t, font_size);
1183       m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
1184       face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
1185                                        font_size,
1186                                        m_pFontInfo->GetFaceIndex(hFont));
1187     }
1188   }
1189   if (face == NULL) {
1190     m_pFontInfo->DeleteFont(hFont);
1191     return NULL;
1192   }
1193   pSubstFont->m_Family = SubstName;
1194   pSubstFont->m_Charset = Charset;
1195   FX_BOOL bNeedUpdateWeight = FALSE;
1196   if (FXFT_Is_Face_Bold(face)) {
1197     if (weight == FXFONT_FW_BOLD) {
1198       bNeedUpdateWeight = FALSE;
1199     } else {
1200       bNeedUpdateWeight = TRUE;
1201     }
1202   } else {
1203     if (weight == FXFONT_FW_NORMAL) {
1204       bNeedUpdateWeight = FALSE;
1205     } else {
1206       bNeedUpdateWeight = TRUE;
1207     }
1208   }
1209   if (bNeedUpdateWeight) {
1210     pSubstFont->m_Weight = weight;
1211   }
1212   if (bItalic && !FXFT_Is_Face_Italic(face)) {
1213     if (italic_angle == 0) {
1214       italic_angle = -12;
1215     } else if (FXSYS_abs(italic_angle) < 5) {
1216       italic_angle = 0;
1217     }
1218     pSubstFont->m_ItalicAngle = italic_angle;
1219   }
1220   m_pFontInfo->DeleteFont(hFont);
1221   return face;
1222 }
1223 extern "C" {
1224 unsigned long _FTStreamRead(FXFT_Stream stream,
1225                             unsigned long offset,
1226                             unsigned char* buffer,
1227                             unsigned long count);
1228 void _FTStreamClose(FXFT_Stream stream);
1229 };
1230 CFontFileFaceInfo::CFontFileFaceInfo() {
1231   m_pFile = NULL;
1232   m_Face = NULL;
1233   m_Charsets = 0;
1234   m_FileSize = 0;
1235   m_FontOffset = 0;
1236   m_Weight = 0;
1237   m_bItalic = FALSE;
1238   m_PitchFamily = 0;
1239 }
1240 CFontFileFaceInfo::~CFontFileFaceInfo() {
1241   if (m_Face) {
1242     FXFT_Done_Face(m_Face);
1243   }
1244   m_Face = NULL;
1245 }
1246 #if _FX_OS_ == _FX_ANDROID_
1247 IFX_SystemFontInfo* IFX_SystemFontInfo::CreateDefault(const char** pUnused) {
1248   return NULL;
1249 }
1250 #endif
1251 CFX_FolderFontInfo::CFX_FolderFontInfo() {}
1252 CFX_FolderFontInfo::~CFX_FolderFontInfo() {
1253   for (const auto& pair : m_FontList) {
1254     delete pair.second;
1255   }
1256 }
1257 void CFX_FolderFontInfo::AddPath(const CFX_ByteStringC& path) {
1258   m_PathList.Add(path);
1259 }
1260 void CFX_FolderFontInfo::Release() {
1261   delete this;
1262 }
1263 FX_BOOL CFX_FolderFontInfo::EnumFontList(CFX_FontMapper* pMapper) {
1264   m_pMapper = pMapper;
1265   for (int i = 0; i < m_PathList.GetSize(); i++) {
1266     ScanPath(m_PathList[i]);
1267   }
1268   return TRUE;
1269 }
1270 void CFX_FolderFontInfo::ScanPath(CFX_ByteString& path) {
1271   void* handle = FX_OpenFolder(path);
1272   if (handle == NULL) {
1273     return;
1274   }
1275   CFX_ByteString filename;
1276   FX_BOOL bFolder;
1277   while (FX_GetNextFile(handle, filename, bFolder)) {
1278     if (bFolder) {
1279       if (filename == "." || filename == "..") {
1280         continue;
1281       }
1282     } else {
1283       CFX_ByteString ext = filename.Right(4);
1284       ext.MakeUpper();
1285       if (ext != ".TTF" && ext != ".OTF" && ext != ".TTC") {
1286         continue;
1287       }
1288     }
1289     CFX_ByteString fullpath = path;
1290 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
1291     fullpath += "\\";
1292 #else
1293     fullpath += "/";
1294 #endif
1295     fullpath += filename;
1296     if (bFolder) {
1297       ScanPath(fullpath);
1298     } else {
1299       ScanFile(fullpath);
1300     }
1301   }
1302   FX_CloseFolder(handle);
1303 }
1304 void CFX_FolderFontInfo::ScanFile(CFX_ByteString& path) {
1305   FXSYS_FILE* pFile = FXSYS_fopen(path, "rb");
1306   if (pFile == NULL) {
1307     return;
1308   }
1309   FXSYS_fseek(pFile, 0, FXSYS_SEEK_END);
1310   FX_DWORD filesize = FXSYS_ftell(pFile);
1311   uint8_t buffer[16];
1312   FXSYS_fseek(pFile, 0, FXSYS_SEEK_SET);
1313   size_t readCnt = FXSYS_fread(buffer, 12, 1, pFile);
1314   if (readCnt != 1) {
1315     FXSYS_fclose(pFile);
1316     return;
1317   }
1318
1319   if (GET_TT_LONG(buffer) == 0x74746366) {
1320     FX_DWORD nFaces = GET_TT_LONG(buffer + 8);
1321     if (nFaces > std::numeric_limits<FX_DWORD>::max() / 4) {
1322       FXSYS_fclose(pFile);
1323       return;
1324     }
1325     FX_DWORD face_bytes = nFaces * 4;
1326     uint8_t* offsets = FX_Alloc(uint8_t, face_bytes);
1327     readCnt = FXSYS_fread(offsets, 1, face_bytes, pFile);
1328     if (readCnt != face_bytes) {
1329       FX_Free(offsets);
1330       FXSYS_fclose(pFile);
1331       return;
1332     }
1333     for (FX_DWORD i = 0; i < nFaces; i++) {
1334       uint8_t* p = offsets + i * 4;
1335       ReportFace(path, pFile, filesize, GET_TT_LONG(p));
1336     }
1337     FX_Free(offsets);
1338   } else {
1339     ReportFace(path, pFile, filesize, 0);
1340   }
1341   FXSYS_fclose(pFile);
1342 }
1343 void CFX_FolderFontInfo::ReportFace(CFX_ByteString& path,
1344                                     FXSYS_FILE* pFile,
1345                                     FX_DWORD filesize,
1346                                     FX_DWORD offset) {
1347   FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
1348   char buffer[16];
1349   if (!FXSYS_fread(buffer, 12, 1, pFile)) {
1350     return;
1351   }
1352   FX_DWORD nTables = GET_TT_SHORT(buffer + 4);
1353   CFX_ByteString tables = _FPDF_ReadStringFromFile(pFile, nTables * 16);
1354   if (tables.IsEmpty()) {
1355     return;
1356   }
1357   CFX_ByteString names =
1358       _FPDF_LoadTableFromTT(pFile, tables, nTables, 0x6e616d65);
1359   CFX_ByteString facename = GetNameFromTT(names, 1);
1360   CFX_ByteString style = GetNameFromTT(names, 2);
1361   if (style != "Regular") {
1362     facename += " " + style;
1363   }
1364   if (m_FontList.find(facename) != m_FontList.end()) {
1365     return;
1366   }
1367   CFX_FontFaceInfo* pInfo =
1368       new CFX_FontFaceInfo(path, facename, tables, offset, filesize);
1369   CFX_ByteString os2 =
1370       _FPDF_LoadTableFromTT(pFile, tables, nTables, 0x4f532f32);
1371   if (os2.GetLength() >= 86) {
1372     const uint8_t* p = (const uint8_t*)os2 + 78;
1373     FX_DWORD codepages = GET_TT_LONG(p);
1374     if (codepages & (1 << 17)) {
1375       m_pMapper->AddInstalledFont(facename, FXFONT_SHIFTJIS_CHARSET);
1376       pInfo->m_Charsets |= CHARSET_FLAG_SHIFTJIS;
1377     }
1378     if (codepages & (1 << 18)) {
1379       m_pMapper->AddInstalledFont(facename, FXFONT_GB2312_CHARSET);
1380       pInfo->m_Charsets |= CHARSET_FLAG_GB;
1381     }
1382     if (codepages & (1 << 20)) {
1383       m_pMapper->AddInstalledFont(facename, FXFONT_CHINESEBIG5_CHARSET);
1384       pInfo->m_Charsets |= CHARSET_FLAG_BIG5;
1385     }
1386     if ((codepages & (1 << 19)) || (codepages & (1 << 21))) {
1387       m_pMapper->AddInstalledFont(facename, FXFONT_HANGEUL_CHARSET);
1388       pInfo->m_Charsets |= CHARSET_FLAG_KOREAN;
1389     }
1390     if (codepages & (1 << 31)) {
1391       m_pMapper->AddInstalledFont(facename, FXFONT_SYMBOL_CHARSET);
1392       pInfo->m_Charsets |= CHARSET_FLAG_SYMBOL;
1393     }
1394   }
1395   m_pMapper->AddInstalledFont(facename, FXFONT_ANSI_CHARSET);
1396   pInfo->m_Charsets |= CHARSET_FLAG_ANSI;
1397   pInfo->m_Styles = 0;
1398   if (style.Find(FX_BSTRC("Bold")) > -1) {
1399     pInfo->m_Styles |= FXFONT_BOLD;
1400   }
1401   if (style.Find(FX_BSTRC("Italic")) > -1 ||
1402       style.Find(FX_BSTRC("Oblique")) > -1) {
1403     pInfo->m_Styles |= FXFONT_ITALIC;
1404   }
1405   if (facename.Find(FX_BSTRC("Serif")) > -1) {
1406     pInfo->m_Styles |= FXFONT_SERIF;
1407   }
1408   m_FontList[facename] = pInfo;
1409 }
1410 void* CFX_FolderFontInfo::MapFont(int weight,
1411                                   FX_BOOL bItalic,
1412                                   int charset,
1413                                   int pitch_family,
1414                                   const FX_CHAR* family,
1415                                   int& iExact) {
1416   return NULL;
1417 }
1418 void* CFX_FolderFontInfo::GetFont(const FX_CHAR* face) {
1419   auto it = m_FontList.find(face);
1420   return it != m_FontList.end() ? it->second : nullptr;
1421 }
1422 FX_DWORD CFX_FolderFontInfo::GetFontData(void* hFont,
1423                                          FX_DWORD table,
1424                                          uint8_t* buffer,
1425                                          FX_DWORD size) {
1426   if (hFont == NULL) {
1427     return 0;
1428   }
1429   CFX_FontFaceInfo* pFont = (CFX_FontFaceInfo*)hFont;
1430   FXSYS_FILE* pFile = NULL;
1431   if (size > 0) {
1432     pFile = FXSYS_fopen(pFont->m_FilePath, "rb");
1433     if (pFile == NULL) {
1434       return 0;
1435     }
1436   }
1437   FX_DWORD datasize = 0;
1438   FX_DWORD offset;
1439   if (table == 0) {
1440     datasize = pFont->m_FontOffset ? 0 : pFont->m_FileSize;
1441     offset = 0;
1442   } else if (table == 0x74746366) {
1443     datasize = pFont->m_FontOffset ? pFont->m_FileSize : 0;
1444     offset = 0;
1445   } else {
1446     FX_DWORD nTables = pFont->m_FontTables.GetLength() / 16;
1447     for (FX_DWORD i = 0; i < nTables; i++) {
1448       const uint8_t* p = (const uint8_t*)pFont->m_FontTables + i * 16;
1449       if (GET_TT_LONG(p) == table) {
1450         offset = GET_TT_LONG(p + 8);
1451         datasize = GET_TT_LONG(p + 12);
1452       }
1453     }
1454   }
1455   if (datasize && size >= datasize && pFile) {
1456     FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
1457     FXSYS_fread(buffer, datasize, 1, pFile);
1458   }
1459   if (pFile) {
1460     FXSYS_fclose(pFile);
1461   }
1462   return datasize;
1463 }
1464 void CFX_FolderFontInfo::DeleteFont(void* hFont) {}
1465 FX_BOOL CFX_FolderFontInfo::GetFaceName(void* hFont, CFX_ByteString& name) {
1466   if (hFont == NULL) {
1467     return FALSE;
1468   }
1469   CFX_FontFaceInfo* pFont = (CFX_FontFaceInfo*)hFont;
1470   name = pFont->m_FaceName;
1471   return TRUE;
1472 }
1473 FX_BOOL CFX_FolderFontInfo::GetFontCharset(void* hFont, int& charset) {
1474   return FALSE;
1475 }