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