vcl/source/font/PhysicalFontCollection.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <memory>
  23
  24 #include <i18nlangtag/languagetag.hxx>
  25 #include <i18nlangtag/mslangid.hxx>
  26 #include <comphelper/configuration.hxx>
  27 #include <unotools/fontdefs.hxx>
  28 #include <o3tl/sorted_vector.hxx>
  29
  30 #include <font/PhysicalFontFaceCollection.hxx>
  31 #include <font/PhysicalFontCollection.hxx>
  32 #include <font/fontsubstitution.hxx>
  33
  34 static ImplFontAttrs lcl_IsCJKFont( std::u16string_view rFontName )
  35 {
  36     // Test, if Fontname includes CJK characters --> In this case we
  37     // mention that it is a CJK font
  38     for(size_t i = 0; i < rFontName.size(); i++)
  39     {
  40         const sal_Unicode ch = rFontName[i];
  41         // japanese
  42         if ( ((ch >= 0x3040) && (ch <= 0x30FF)) ||
  43              ((ch >= 0x3190) && (ch <= 0x319F)) )
  44             return ImplFontAttrs::CJK|ImplFontAttrs::CJK_JP;
  45
  46         // korean
  47         if ( ((ch >= 0xAC00) && (ch <= 0xD7AF)) ||
  48              ((ch >= 0xA960) && (ch <= 0xA97F)) ||
  49              ((ch >= 0xD7B0) && (ch <= 0xD7FF)) ||
  50              ((ch >= 0x3130) && (ch <= 0x318F)) ||
  51              ((ch >= 0x1100) && (ch <= 0x11FF)) )
  52             return ImplFontAttrs::CJK|ImplFontAttrs::CJK_KR;
  53
  54         // chinese
  55         if ( (ch >= 0x3400) && (ch <= 0x9FFF) )
  56             return ImplFontAttrs::CJK|ImplFontAttrs::CJK_TC|ImplFontAttrs::CJK_SC;
  57
  58         // cjk
  59         if ( ((ch >= 0x3000) && (ch <= 0xD7AF)) ||
  60              ((ch >= 0xFF00) && (ch <= 0xFFEE)) )
  61             return ImplFontAttrs::CJK;
  62
  63     }
  64
  65     return ImplFontAttrs::None;
  66 }
  67
  68 namespace vcl::font
  69 {
  70
  71 PhysicalFontCollection::PhysicalFontCollection()
  72     : mbMatchData( false )
  73     , mpPreMatchHook( nullptr )
  74     , mpFallbackHook( nullptr )
  75     , mnFallbackCount( -1 )
  76 {}
  77
  78 PhysicalFontCollection::~PhysicalFontCollection()
  79 {
  80     Clear();
  81 }
  82
  83 void PhysicalFontCollection::SetPreMatchHook(PreMatchFontSubstitution* pHook)
  84 {
  85     mpPreMatchHook = pHook;
  86 }
  87
  88 void PhysicalFontCollection::SetFallbackHook(GlyphFallbackFontSubstitution* pHook)
  89 {
  90     mpFallbackHook = pHook;
  91 }
  92
  93 void PhysicalFontCollection::Clear()
  94 {
  95     // remove fallback lists
  96     mpFallbackList.reset();
  97     mnFallbackCount = -1;
  98
  99     // clear all entries in the device font list
 100     maPhysicalFontFamilies.clear();
 101
 102     // match data must be recalculated too
 103     mbMatchData = false;
 104 }
 105
 106 void PhysicalFontCollection::ImplInitGenericGlyphFallback() const
 107 {
 108     // normalized family names of fonts suited for glyph fallback
 109     // if a font is available related fonts can be ignored
 110     // TODO: implement dynamic lists
 111     static const char* aGlyphFallbackList[] = {
 112         // empty strings separate the names of unrelated fonts
 113         "eudc", "",
 114         "arialunicodems", "cyberbit", "code2000", "",
 115         "andalesansui", "",
 116         "starsymbol", "opensymbol", "",
 117         "msmincho", "fzmingti", "fzheiti", "ipamincho", "sazanamimincho", "kochimincho", "",
 118         "sunbatang", "sundotum", "baekmukdotum", "gulim", "batang", "dotum", "",
 119         "hgmincholightj", "msunglightsc", "msunglighttc", "hymyeongjolightk", "",
 120         "tahoma", "dejavusans", "timesnewroman", "liberationsans", "",
 121         "shree", "mangal", "",
 122         "raavi", "shruti", "tunga", "",
 123         "latha", "gautami", "kartika", "vrinda", "",
 124         "shayyalmt", "naskmt", "scheherazade", "",
 125         "david", "nachlieli", "lucidagrande", "",
 126         "norasi", "angsanaupc", "",
 127         "khmerossystem", "",
 128         "muktinarrow", "",
 129         "phetsarathot", "",
 130         "padauk", "pinlonmyanmar", "",
 131         "iskoolapota", "lklug", "",
 132         nullptr
 133     };
 134
 135     bool bHasEudc = false;
 136     int nMaxLevel = 0;
 137     int nBestQuality = 0;
 138     std::unique_ptr<std::array<PhysicalFontFamily*,MAX_GLYPHFALLBACK>> pFallbackList;
 139
 140     for( const char** ppNames = &aGlyphFallbackList[0];; ++ppNames )
 141     {
 142         // advance to next sub-list when end-of-sublist marker
 143         if( !**ppNames ) // #i46456# check for empty string, i.e., deref string itself not only ptr to it
 144         {
 145             if( nBestQuality > 0 )
 146                 if( ++nMaxLevel >= MAX_GLYPHFALLBACK )
 147                     break;
 148
 149             if( !ppNames[1] )
 150                 break;
 151
 152             nBestQuality = 0;
 153             continue;
 154         }
 155
 156         // test if the glyph fallback candidate font is available and scalable
 157         OUString aTokenName( *ppNames, strlen(*ppNames), RTL_TEXTENCODING_UTF8 );
 158         PhysicalFontFamily* pFallbackFont = FindFontFamily( aTokenName );
 159
 160         if( !pFallbackFont )
 161             continue;
 162
 163         // keep the best font of the glyph fallback sub-list
 164         if( nBestQuality < pFallbackFont->GetMinQuality() )
 165         {
 166             nBestQuality = pFallbackFont->GetMinQuality();
 167             // store available glyph fallback fonts
 168             if( !pFallbackList )
 169                 pFallbackList.reset(new std::array<PhysicalFontFamily*,MAX_GLYPHFALLBACK>);
 170
 171             (*pFallbackList)[ nMaxLevel ] = pFallbackFont;
 172             if( !bHasEudc && !nMaxLevel )
 173                 bHasEudc = !strncmp( *ppNames, "eudc", 5 );
 174         }
 175     }
 176
 177     mnFallbackCount = nMaxLevel;
 178     mpFallbackList  = std::move(pFallbackList);
 179 }
 180
 181 PhysicalFontFamily* PhysicalFontCollection::GetGlyphFallbackFont(FontSelectPattern& rFontSelData,
 182                                                                  LogicalFontInstance* pFontInstance,
 183                                                                  OUString& rMissingCodes,
 184                                                                  int nFallbackLevel) const
 185 {
 186     PhysicalFontFamily* pFallbackData = nullptr;
 187
 188     // find a matching font candidate for platform specific glyph fallback
 189     if( mpFallbackHook )
 190     {
 191         // check cache for the first matching entry
 192         // to avoid calling the expensive fallback hook (#i83491#)
 193         sal_UCS4 cChar = 0;
 194         bool bCached = true;
 195         sal_Int32 nStrIndex = 0;
 196         while( nStrIndex < rMissingCodes.getLength() )
 197         {
 198             cChar = rMissingCodes.iterateCodePoints( &nStrIndex );
 199             bCached = pFontInstance->GetFallbackForUnicode(cChar, rFontSelData.GetWeight(),
 200                                                            &rFontSelData.maSearchName,
 201                                                            &rFontSelData.mbEmbolden,
 202                                                            &rFontSelData.maItalicMatrix);
 203
 204             // ignore entries which don't have a fallback
 205             if( !bCached || !rFontSelData.maSearchName.isEmpty() )
 206                 break;
 207         }
 208
 209         if( bCached )
 210         {
 211             // there is a matching fallback in the cache
 212             // so update rMissingCodes with codepoints not yet resolved by this fallback
 213             int nRemainingLength = 0;
 214             std::unique_ptr<sal_UCS4[]> const pRemainingCodes(new sal_UCS4[rMissingCodes.getLength()]);
 215             OUString aFontName;
 216             bool bEmbolden;
 217             ItalicMatrix aMatrix;
 218
 219             while( nStrIndex < rMissingCodes.getLength() )
 220             {
 221                 cChar = rMissingCodes.iterateCodePoints( &nStrIndex );
 222                 bCached = pFontInstance->GetFallbackForUnicode(cChar, rFontSelData.GetWeight(),
 223                                                                &aFontName, &bEmbolden, &aMatrix);
 224                 if (!bCached || rFontSelData.maSearchName != aFontName ||
 225                                 rFontSelData.mbEmbolden != bEmbolden ||
 226                                 rFontSelData.maItalicMatrix != aMatrix)
 227                 {
 228                     pRemainingCodes[ nRemainingLength++ ] = cChar;
 229                 }
 230             }
 231             rMissingCodes = OUString( pRemainingCodes.get(), nRemainingLength );
 232         }
 233         else
 234         {
 235             OUString aOldMissingCodes = rMissingCodes;
 236
 237             // call the hook to query the best matching glyph fallback font
 238             if (mpFallbackHook->FindFontSubstitute(rFontSelData, pFontInstance, rMissingCodes))
 239                 // apply outdev3.cxx specific fontname normalization
 240                 rFontSelData.maSearchName = GetEnglishSearchFontName( rFontSelData.maSearchName );
 241             else
 242                 rFontSelData.maSearchName.clear();
 243
 244             // Cache the result even if there was no match
 245             // See tdf#32665 and tdf#147283 for an example where FreeSerif that has glyphs that exist
 246             // in the bold font, but not in the bold+italic version where fontconfig suggest the bold
 247             // font + applying a matrix to fake the missing italic.
 248             for(;;)
 249             {
 250                  if (!pFontInstance->GetFallbackForUnicode(cChar, rFontSelData.GetWeight(),
 251                                                            &rFontSelData.maSearchName,
 252                                                            &rFontSelData.mbEmbolden,
 253                                                            &rFontSelData.maItalicMatrix))
 254                  {
 255                      pFontInstance->AddFallbackForUnicode(cChar, rFontSelData.GetWeight(),
 256                                                           rFontSelData.maSearchName,
 257                                                           rFontSelData.mbEmbolden,
 258                                                           rFontSelData.maItalicMatrix);
 259                  }
 260                  if( nStrIndex >= aOldMissingCodes.getLength() )
 261                      break;
 262                  cChar = aOldMissingCodes.iterateCodePoints( &nStrIndex );
 263             }
 264             if( !rFontSelData.maSearchName.isEmpty() )
 265             {
 266                 // remove cache entries that were still not resolved
 267                 for( nStrIndex = 0; nStrIndex < rMissingCodes.getLength(); )
 268                 {
 269                     cChar = rMissingCodes.iterateCodePoints( &nStrIndex );
 270                     pFontInstance->IgnoreFallbackForUnicode( cChar, rFontSelData.GetWeight(), rFontSelData.maSearchName );
 271                 }
 272             }
 273         }
 274
 275         // find the matching device font
 276         if( !rFontSelData.maSearchName.isEmpty() )
 277             pFallbackData = FindFontFamily( rFontSelData.maSearchName );
 278     }
 279
 280     // else find a matching font candidate for generic glyph fallback
 281     if( !pFallbackData )
 282     {
 283         // initialize font candidates for generic glyph fallback if needed
 284         if( mnFallbackCount < 0 )
 285             ImplInitGenericGlyphFallback();
 286
 287         // TODO: adjust nFallbackLevel by number of levels resolved by the fallback hook
 288         if( nFallbackLevel < mnFallbackCount )
 289             pFallbackData = (*mpFallbackList)[ nFallbackLevel ];
 290     }
 291
 292     return pFallbackData;
 293 }
 294
 295 void PhysicalFontCollection::Add(PhysicalFontFace* pNewData)
 296 {
 297     OUString aSearchName = GetEnglishSearchFontName( pNewData->GetFamilyName() );
 298
 299     PhysicalFontFamily* pFoundData = FindOrCreateFontFamily(aSearchName);
 300
 301     pFoundData->AddFontFace( pNewData );
 302 }
 303
 304 // find the font from the normalized font family name
 305 PhysicalFontFamily* PhysicalFontCollection::ImplFindFontFamilyBySearchName(const OUString& rSearchName) const
 306 {
 307     // must be called with a normalized name.
 308     assert( GetEnglishSearchFontName( rSearchName ) == rSearchName );
 309
 310     PhysicalFontFamilies::const_iterator it = maPhysicalFontFamilies.find( rSearchName );
 311     if( it == maPhysicalFontFamilies.end() )
 312         return nullptr;
 313
 314     PhysicalFontFamily* pFoundData = (*it).second.get();
 315     return pFoundData;
 316 }
 317
 318 PhysicalFontFamily* PhysicalFontCollection::FindFontFamily(std::u16string_view rFontName) const
 319 {
 320     return ImplFindFontFamilyBySearchName( GetEnglishSearchFontName( rFontName ) );
 321 }
 322
 323 PhysicalFontFamily *PhysicalFontCollection::FindOrCreateFontFamily(OUString const& rFamilyName)
 324 {
 325     PhysicalFontFamilies::const_iterator it = maPhysicalFontFamilies.find( rFamilyName );
 326     PhysicalFontFamily* pFoundData = nullptr;
 327
 328     if( it != maPhysicalFontFamilies.end() )
 329         pFoundData = (*it).second.get();
 330
 331     if( !pFoundData )
 332     {
 333         pFoundData = new PhysicalFontFamily(rFamilyName);
 334         maPhysicalFontFamilies[ rFamilyName ].reset(pFoundData);
 335     }
 336
 337     return pFoundData;
 338 }
 339
 340 PhysicalFontFamily* PhysicalFontCollection::FindFontFamilyByTokenNames(std::u16string_view rTokenStr) const
 341 {
 342     PhysicalFontFamily* pFoundData = nullptr;
 343
 344     // use normalized font name tokens to find the font
 345     for( sal_Int32 nTokenPos = 0; nTokenPos != -1; )
 346     {
 347         std::u16string_view aFamilyName = GetNextFontToken( rTokenStr, nTokenPos );
 348         if( aFamilyName.empty() )
 349             continue;
 350
 351         pFoundData = FindFontFamily( aFamilyName );
 352
 353         if( pFoundData )
 354             break;
 355     }
 356
 357     return pFoundData;
 358 }
 359
 360 PhysicalFontFamily* PhysicalFontCollection::ImplFindFontFamilyBySubstFontAttr(utl::FontNameAttr const& rFontAttr) const
 361 {
 362     PhysicalFontFamily* pFoundData = nullptr;
 363
 364     // use the font substitutions suggested by the FontNameAttr to find the font
 365     for (auto const& substitution : rFontAttr.Substitutions)
 366     {
 367         pFoundData = FindFontFamily(substitution);
 368         if( pFoundData )
 369             return pFoundData;
 370     }
 371
 372     // use known attributes from the configuration to find a matching substitute
 373     const ImplFontAttrs nSearchType = rFontAttr.Type;
 374     if( nSearchType != ImplFontAttrs::None )
 375     {
 376         const FontWeight eSearchWeight = rFontAttr.Weight;
 377         const FontWidth  eSearchWidth  = rFontAttr.Width;
 378         const FontItalic eSearchSlant  = ITALIC_DONTKNOW;
 379
 380         pFoundData = FindFontFamilyByAttributes( nSearchType,
 381             eSearchWeight, eSearchWidth, eSearchSlant, u"" );
 382
 383         if( pFoundData )
 384             return pFoundData;
 385     }
 386
 387     return nullptr;
 388 }
 389
 390 void PhysicalFontCollection::ImplInitMatchData() const
 391 {
 392     // short circuit if already done
 393     if( mbMatchData )
 394         return;
 395     mbMatchData = true;
 396
 397     if (comphelper::IsFuzzing())
 398         return;
 399
 400     // calculate MatchData for all entries
 401     const utl::FontSubstConfiguration& rFontSubst = utl::FontSubstConfiguration::get();
 402
 403     for (auto const& family : maPhysicalFontFamilies)
 404     {
 405         const OUString& rSearchName = family.first;
 406         PhysicalFontFamily* pEntry = family.second.get();
 407
 408         pEntry->InitMatchData( rFontSubst, rSearchName );
 409     }
 410 }
 411
 412 PhysicalFontFamily* PhysicalFontCollection::FindFontFamilyByAttributes(ImplFontAttrs nSearchType,
 413                                                                        FontWeight eSearchWeight,
 414                                                                        FontWidth eSearchWidth,
 415                                                                        FontItalic eSearchItalic,
 416                                                                        std::u16string_view rSearchFamilyName ) const
 417 {
 418     if( (eSearchItalic != ITALIC_NONE) && (eSearchItalic != ITALIC_DONTKNOW) )
 419         nSearchType |= ImplFontAttrs::Italic;
 420
 421     // don't bother to match attributes if the attributes aren't worth matching
 422     if( nSearchType == ImplFontAttrs::None
 423     && ((eSearchWeight == WEIGHT_DONTKNOW) || (eSearchWeight == WEIGHT_NORMAL))
 424     && ((eSearchWidth == WIDTH_DONTKNOW) || (eSearchWidth == WIDTH_NORMAL)) )
 425         return nullptr;
 426
 427     ImplInitMatchData();
 428     PhysicalFontFamily* pFoundData = nullptr;
 429
 430     tools::Long    nBestMatch = 40000;
 431     ImplFontAttrs  nBestType = ImplFontAttrs::None;
 432
 433     for (auto const& family : maPhysicalFontFamilies)
 434     {
 435         PhysicalFontFamily* pData = family.second.get();
 436
 437         // Get all information about the matching font
 438         ImplFontAttrs nMatchType  = pData->GetMatchType();
 439         FontWeight    eMatchWeight= pData->GetMatchWeight();
 440         FontWidth     eMatchWidth = pData->GetMatchWidth();
 441
 442         // Calculate Match Value
 443         // 1000000000
 444         //  100000000
 445         //   10000000   CJK, CTL, None-Latin, Symbol
 446         //    1000000   FamilyName, Script, Fixed, -Special, -Decorative,
 447         //              Titling, Capitals, Outline, Shadow
 448         //     100000   Match FamilyName, Serif, SansSerif, Italic,
 449         //              Width, Weight
 450         //      10000   Scalable, Standard, Default,
 451         //              full, Normal, Knownfont,
 452         //              Otherstyle, +Special, +Decorative,
 453         //       1000   Typewriter, Rounded, Gothic, Schollbook
 454         //        100
 455         tools::Long nTestMatch = 0;
 456
 457         // test CJK script attributes
 458         if ( nSearchType & ImplFontAttrs::CJK )
 459         {
 460             // if the matching font doesn't support any CJK languages, then
 461             // it is not appropriate
 462             if ( !(nMatchType & ImplFontAttrs::CJK_AllLang) )
 463             {
 464                 nTestMatch -= 10000000;
 465             }
 466             else
 467             {
 468                 // Matching language
 469                 if ( (nSearchType & ImplFontAttrs::CJK_AllLang)
 470                     && (nMatchType & ImplFontAttrs::CJK_AllLang) )
 471                     nTestMatch += 10000000*3;
 472                 if ( nMatchType & ImplFontAttrs::CJK )
 473                     nTestMatch += 10000000*2;
 474                 if ( nMatchType & ImplFontAttrs::Full )
 475                     nTestMatch += 10000000;
 476             }
 477         }
 478         else if ( nMatchType & ImplFontAttrs::CJK )
 479         {
 480             nTestMatch -= 10000000;
 481         }
 482
 483         // test CTL script attributes
 484         if( nSearchType & ImplFontAttrs::CTL )
 485         {
 486             if( nMatchType & ImplFontAttrs::CTL )
 487                 nTestMatch += 10000000*2;
 488             if( nMatchType & ImplFontAttrs::Full )
 489                 nTestMatch += 10000000;
 490         }
 491         else if ( nMatchType & ImplFontAttrs::CTL )
 492         {
 493             nTestMatch -= 10000000;
 494         }
 495
 496         // test LATIN script attributes
 497         if( nSearchType & ImplFontAttrs::NoneLatin )
 498         {
 499             if( nMatchType & ImplFontAttrs::NoneLatin )
 500                 nTestMatch += 10000000*2;
 501             if( nMatchType & ImplFontAttrs::Full )
 502                 nTestMatch += 10000000;
 503         }
 504
 505         // test SYMBOL attributes
 506         if ( nSearchType & ImplFontAttrs::Symbol )
 507         {
 508             const OUString& rSearchName = family.first;
 509             // prefer some special known symbol fonts
 510             if ( rSearchName == "starsymbol" )
 511             {
 512                 nTestMatch += 10000000*6+(10000*3);
 513             }
 514             else if ( rSearchName == "opensymbol" )
 515             {
 516                 nTestMatch += 10000000*6;
 517             }
 518             else if ( rSearchName == "starbats" ||
 519                       rSearchName == "wingdings" ||
 520                       rSearchName == "monotypesorts" ||
 521                       rSearchName == "dingbats" ||
 522                       rSearchName == "zapfdingbats" )
 523             {
 524                 nTestMatch += 10000000*5;
 525             }
 526             else if (pData->GetTypeFaces() & FontTypeFaces::Symbol)
 527             {
 528                 nTestMatch += 10000000*4;
 529             }
 530             else
 531             {
 532                 if( nMatchType & ImplFontAttrs::Symbol )
 533                     nTestMatch += 10000000*2;
 534                 if( nMatchType & ImplFontAttrs::Full )
 535                     nTestMatch += 10000000;
 536             }
 537         }
 538         else if ((pData->GetTypeFaces() & (FontTypeFaces::Symbol | FontTypeFaces::NoneSymbol)) == FontTypeFaces::Symbol)
 539         {
 540             nTestMatch -= 10000000;
 541         }
 542         else if ( nMatchType & ImplFontAttrs::Symbol )
 543         {
 544             nTestMatch -= 10000;
 545         }
 546
 547         // match stripped family name
 548         if( !rSearchFamilyName.empty() && (rSearchFamilyName == pData->GetMatchFamilyName()) )
 549         {
 550             nTestMatch += 1000000*3;
 551         }
 552
 553         // match ALLSCRIPT? attribute
 554         if( nSearchType & ImplFontAttrs::AllScript )
 555         {
 556             if( nMatchType & ImplFontAttrs::AllScript )
 557             {
 558                 nTestMatch += 1000000*2;
 559             }
 560             if( nSearchType & ImplFontAttrs::AllSubscript )
 561             {
 562                 if( ImplFontAttrs::None == ((nSearchType ^ nMatchType) & ImplFontAttrs::AllSubscript) )
 563                     nTestMatch += 1000000*2;
 564                 if( ImplFontAttrs::None != ((nSearchType ^ nMatchType) & ImplFontAttrs::BrushScript) )
 565                     nTestMatch -= 1000000;
 566             }
 567         }
 568         else if( nMatchType & ImplFontAttrs::AllScript )
 569         {
 570             nTestMatch -= 1000000;
 571         }
 572
 573         // test MONOSPACE+TYPEWRITER attributes
 574         if( nSearchType & ImplFontAttrs::Fixed )
 575         {
 576             if( nMatchType & ImplFontAttrs::Fixed )
 577                 nTestMatch += 1000000*2;
 578             // a typewriter attribute is even better
 579             if( ImplFontAttrs::None == ((nSearchType ^ nMatchType) & ImplFontAttrs::Typewriter) )
 580                 nTestMatch += 10000*2;
 581         }
 582         else if( nMatchType & ImplFontAttrs::Fixed )
 583         {
 584             nTestMatch -= 1000000;
 585         }
 586
 587         // test SPECIAL attribute
 588         if( nSearchType & ImplFontAttrs::Special )
 589         {
 590             if( nMatchType & ImplFontAttrs::Special )
 591             {
 592                 nTestMatch += 10000;
 593             }
 594             else if( !(nSearchType & ImplFontAttrs::AllSerifStyle) )
 595             {
 596                  if( nMatchType & ImplFontAttrs::Serif )
 597                  {
 598                      nTestMatch += 1000*2;
 599                  }
 600                  else if( nMatchType & ImplFontAttrs::SansSerif )
 601                  {
 602                      nTestMatch += 1000;
 603                  }
 604              }
 605         }
 606         else if( (nMatchType & ImplFontAttrs::Special) && !(nSearchType & ImplFontAttrs::Symbol) )
 607         {
 608             nTestMatch -= 1000000;
 609         }
 610
 611         // test DECORATIVE attribute
 612         if( nSearchType & ImplFontAttrs::Decorative )
 613         {
 614             if( nMatchType & ImplFontAttrs::Decorative )
 615             {
 616                 nTestMatch += 10000;
 617             }
 618             else if( !(nSearchType & ImplFontAttrs::AllSerifStyle) )
 619             {
 620                 if( nMatchType & ImplFontAttrs::Serif )
 621                     nTestMatch += 1000*2;
 622                 else if ( nMatchType & ImplFontAttrs::SansSerif )
 623                     nTestMatch += 1000;
 624             }
 625         }
 626         else if( nMatchType & ImplFontAttrs::Decorative )
 627         {
 628             nTestMatch -= 1000000;
 629         }
 630
 631         // test TITLE+CAPITALS attributes
 632         if( nSearchType & (ImplFontAttrs::Titling | ImplFontAttrs::Capitals) )
 633         {
 634             if( nMatchType & (ImplFontAttrs::Titling | ImplFontAttrs::Capitals) )
 635             {
 636                 nTestMatch += 1000000*2;
 637             }
 638             if( ImplFontAttrs::None == ((nSearchType^nMatchType) & ImplFontAttrs(ImplFontAttrs::Titling | ImplFontAttrs::Capitals)))
 639             {
 640                 nTestMatch += 1000000;
 641             }
 642             else if( (nMatchType & (ImplFontAttrs::Titling | ImplFontAttrs::Capitals)) &&
 643                      (nMatchType & (ImplFontAttrs::Standard | ImplFontAttrs::Default)) )
 644             {
 645                 nTestMatch += 1000000;
 646             }
 647         }
 648         else if( nMatchType & (ImplFontAttrs::Titling | ImplFontAttrs::Capitals) )
 649         {
 650             nTestMatch -= 1000000;
 651         }
 652
 653         // test OUTLINE+SHADOW attributes
 654         if( nSearchType & (ImplFontAttrs::Outline | ImplFontAttrs::Shadow) )
 655         {
 656             if( nMatchType & (ImplFontAttrs::Outline | ImplFontAttrs::Shadow) )
 657             {
 658                 nTestMatch += 1000000*2;
 659             }
 660             if( ImplFontAttrs::None == ((nSearchType ^ nMatchType) & ImplFontAttrs(ImplFontAttrs::Outline | ImplFontAttrs::Shadow)) )
 661             {
 662                 nTestMatch += 1000000;
 663             }
 664             else if( (nMatchType & (ImplFontAttrs::Outline | ImplFontAttrs::Shadow)) &&
 665                      (nMatchType & (ImplFontAttrs::Standard | ImplFontAttrs::Default)) )
 666             {
 667                 nTestMatch += 1000000;
 668             }
 669         }
 670         else if ( nMatchType & (ImplFontAttrs::Outline | ImplFontAttrs::Shadow) )
 671         {
 672             nTestMatch -= 1000000;
 673         }
 674
 675         // test font name substrings
 676         // TODO: calculate name matching score using e.g. Levenstein distance
 677         if( (rSearchFamilyName.size() >= 4) &&
 678             (pData->GetMatchFamilyName().getLength() >= 4) &&
 679             ((rSearchFamilyName.find( pData->GetMatchFamilyName() ) != std::u16string_view::npos) ||
 680              (pData->GetMatchFamilyName().indexOf( rSearchFamilyName ) != -1)) )
 681         {
 682             nTestMatch += 5000;
 683         }
 684         // test SERIF attribute
 685         if( nSearchType & ImplFontAttrs::Serif )
 686         {
 687             if( nMatchType & ImplFontAttrs::Serif )
 688                 nTestMatch += 1000000*2;
 689             else if( nMatchType & ImplFontAttrs::SansSerif )
 690                 nTestMatch -= 1000000;
 691         }
 692
 693         // test SANSERIF attribute
 694         if( nSearchType & ImplFontAttrs::SansSerif )
 695         {
 696             if( nMatchType & ImplFontAttrs::SansSerif )
 697                 nTestMatch += 1000000;
 698             else if ( nMatchType & ImplFontAttrs::Serif )
 699                 nTestMatch -= 1000000;
 700         }
 701
 702         // test ITALIC attribute
 703         if( nSearchType & ImplFontAttrs::Italic )
 704         {
 705             if (pData->GetTypeFaces() & FontTypeFaces::Italic)
 706                 nTestMatch += 1000000*3;
 707             if( nMatchType & ImplFontAttrs::Italic )
 708                 nTestMatch += 1000000;
 709         }
 710         else if (!(nSearchType & ImplFontAttrs::AllScript)
 711                  && ((nMatchType & ImplFontAttrs::Italic)
 712                  || !(pData->GetTypeFaces() & FontTypeFaces::NoneItalic)))
 713         {
 714             nTestMatch -= 1000000*2;
 715         }
 716
 717         // test WIDTH attribute
 718         if( (eSearchWidth != WIDTH_DONTKNOW) && (eSearchWidth != WIDTH_NORMAL) )
 719         {
 720             if( eSearchWidth < WIDTH_NORMAL )
 721             {
 722                 if( eSearchWidth == eMatchWidth )
 723                     nTestMatch += 1000000*3;
 724                 else if( (eMatchWidth < WIDTH_NORMAL) && (eMatchWidth != WIDTH_DONTKNOW) )
 725                     nTestMatch += 1000000;
 726             }
 727             else
 728             {
 729                 if( eSearchWidth == eMatchWidth )
 730                     nTestMatch += 1000000*3;
 731                 else if( eMatchWidth > WIDTH_NORMAL )
 732                     nTestMatch += 1000000;
 733             }
 734         }
 735         else if( (eMatchWidth != WIDTH_DONTKNOW) && (eMatchWidth != WIDTH_NORMAL) )
 736         {
 737             nTestMatch -= 1000000;
 738         }
 739
 740         // test WEIGHT attribute
 741         if( (eSearchWeight != WEIGHT_DONTKNOW) &&
 742             (eSearchWeight != WEIGHT_NORMAL) &&
 743             (eSearchWeight != WEIGHT_MEDIUM) )
 744         {
 745             if( eSearchWeight < WEIGHT_NORMAL )
 746             {
 747                 if (pData->GetTypeFaces() & FontTypeFaces::Light)
 748                     nTestMatch += 1000000;
 749                 if( (eMatchWeight < WEIGHT_NORMAL) && (eMatchWeight != WEIGHT_DONTKNOW) )
 750                     nTestMatch += 1000000;
 751             }
 752             else
 753             {
 754                 if (pData->GetTypeFaces() & FontTypeFaces::Bold)
 755                     nTestMatch += 1000000;
 756                 if( eMatchWeight > WEIGHT_BOLD )
 757                     nTestMatch += 1000000;
 758             }
 759         }
 760         else if (((eMatchWeight != WEIGHT_DONTKNOW)
 761                   && (eMatchWeight != WEIGHT_NORMAL)
 762                   && (eMatchWeight != WEIGHT_MEDIUM))
 763                   || !(pData->GetTypeFaces() & FontTypeFaces::Normal))
 764         {
 765             nTestMatch -= 1000000;
 766         }
 767
 768         // prefer scalable fonts
 769         if (pData->GetTypeFaces() & FontTypeFaces::Scalable)
 770             nTestMatch += 10000*4;
 771         else
 772             nTestMatch -= 10000*4;
 773
 774         // test STANDARD+DEFAULT+FULL+NORMAL attributes
 775         if( nMatchType & ImplFontAttrs::Standard )
 776             nTestMatch += 10000*2;
 777         if( nMatchType & ImplFontAttrs::Default )
 778             nTestMatch += 10000;
 779         if( nMatchType & ImplFontAttrs::Full )
 780             nTestMatch += 10000;
 781         if( nMatchType & ImplFontAttrs::Normal )
 782             nTestMatch += 10000;
 783
 784         // test OTHERSTYLE attribute
 785         if( ((nSearchType ^ nMatchType) & ImplFontAttrs::OtherStyle) != ImplFontAttrs::None )
 786         {
 787             nTestMatch -= 10000;
 788         }
 789
 790         // test ROUNDED attribute
 791         if( ImplFontAttrs::None == ((nSearchType ^ nMatchType) & ImplFontAttrs::Rounded) )
 792             nTestMatch += 1000;
 793
 794         // test TYPEWRITER attribute
 795         if( ImplFontAttrs::None == ((nSearchType ^ nMatchType) & ImplFontAttrs::Typewriter) )
 796             nTestMatch += 1000;
 797
 798         // test GOTHIC attribute
 799         if( nSearchType & ImplFontAttrs::Gothic )
 800         {
 801             if( nMatchType & ImplFontAttrs::Gothic )
 802                 nTestMatch += 1000*3;
 803             if( nMatchType & ImplFontAttrs::SansSerif )
 804                 nTestMatch += 1000*2;
 805         }
 806
 807         // test SCHOOLBOOK attribute
 808         if( nSearchType & ImplFontAttrs::Schoolbook )
 809         {
 810             if( nMatchType & ImplFontAttrs::Schoolbook )
 811                 nTestMatch += 1000*3;
 812             if( nMatchType & ImplFontAttrs::Serif )
 813                 nTestMatch += 1000*2;
 814         }
 815
 816         // compare with best matching font yet
 817         if ( nTestMatch > nBestMatch )
 818         {
 819             pFoundData  = pData;
 820             nBestMatch  = nTestMatch;
 821             nBestType   = nMatchType;
 822         }
 823         else if( nTestMatch == nBestMatch )
 824         {
 825             // some fonts are more suitable defaults
 826             if( nMatchType & ImplFontAttrs::Default )
 827             {
 828                 pFoundData  = pData;
 829                 nBestType   = nMatchType;
 830             }
 831             else if( (nMatchType & ImplFontAttrs::Standard) &&
 832                     !(nBestType & ImplFontAttrs::Default) )
 833             {
 834                  pFoundData  = pData;
 835                  nBestType   = nMatchType;
 836             }
 837         }
 838     }
 839
 840     return pFoundData;
 841 }
 842
 843 PhysicalFontFamily* PhysicalFontCollection::ImplFindFontFamilyOfDefaultFont() const
 844 {
 845     // try to find one of the default fonts of the
 846     // UNICODE, SANSSERIF, SERIF or FIXED default font lists
 847     PhysicalFontFamily* pFoundData = nullptr;
 848     if (!comphelper::IsFuzzing())
 849     {
 850         const utl::DefaultFontConfiguration& rDefaults = utl::DefaultFontConfiguration::get();
 851         LanguageTag aLanguageTag(u"en"_ustr);
 852         OUString aFontname = rDefaults.getDefaultFont( aLanguageTag, DefaultFontType::SANS_UNICODE );
 853         pFoundData = FindFontFamilyByTokenNames( aFontname );
 854
 855         if( pFoundData )
 856             return pFoundData;
 857
 858         aFontname = rDefaults.getDefaultFont( aLanguageTag, DefaultFontType::SANS );
 859         pFoundData = FindFontFamilyByTokenNames( aFontname );
 860         if( pFoundData )
 861             return pFoundData;
 862
 863         aFontname = rDefaults.getDefaultFont( aLanguageTag, DefaultFontType::SERIF );
 864         pFoundData = FindFontFamilyByTokenNames( aFontname );
 865         if( pFoundData )
 866             return pFoundData;
 867
 868         aFontname = rDefaults.getDefaultFont( aLanguageTag, DefaultFontType::FIXED );
 869         pFoundData = FindFontFamilyByTokenNames( aFontname );
 870         if( pFoundData )
 871             return pFoundData;
 872     }
 873
 874     // now try to find a reasonable non-symbol font
 875
 876     ImplInitMatchData();
 877
 878     for (auto const& family : maPhysicalFontFamilies)
 879     {
 880         PhysicalFontFamily* pData = family.second.get();
 881         if( pData->GetMatchType() & ImplFontAttrs::Symbol )
 882             continue;
 883
 884         pFoundData = pData;
 885         if( pData->GetMatchType() & (ImplFontAttrs::Default|ImplFontAttrs::Standard) )
 886             break;
 887     }
 888     if( pFoundData )
 889         return pFoundData;
 890
 891     // finding any font is better than finding no font at all
 892     auto it = maPhysicalFontFamilies.begin();
 893     if( it !=  maPhysicalFontFamilies.end() )
 894         pFoundData = (*it).second.get();
 895
 896     return pFoundData;
 897 }
 898
 899 std::shared_ptr<PhysicalFontCollection> PhysicalFontCollection::Clone() const
 900 {
 901     auto xClonedCollection = std::make_shared<PhysicalFontCollection>();
 902     xClonedCollection->mpPreMatchHook = mpPreMatchHook;
 903     xClonedCollection->mpFallbackHook = mpFallbackHook;
 904
 905     // TODO: clone the config-font attributes too?
 906     xClonedCollection->mbMatchData    = false;
 907
 908     for (auto const& family : maPhysicalFontFamilies)
 909     {
 910         const PhysicalFontFamily* pFontFace = family.second.get();
 911         pFontFace->UpdateCloneFontList(*xClonedCollection);
 912     }
 913
 914     return xClonedCollection;
 915 }
 916
 917 std::unique_ptr<PhysicalFontFaceCollection> PhysicalFontCollection::GetFontFaceCollection() const
 918 {
 919     std::unique_ptr<PhysicalFontFaceCollection> pDeviceFontList(new PhysicalFontFaceCollection);
 920
 921     for (auto const& family : maPhysicalFontFamilies)
 922     {
 923         const PhysicalFontFamily* pFontFamily = family.second.get();
 924         pFontFamily->UpdateDevFontList( *pDeviceFontList );
 925     }
 926
 927     return pDeviceFontList;
 928 }
 929
 930 // These are the metric-compatible replacement fonts that are bundled with
 931 // LibreOffice, we prefer them over generic substitutions that might be
 932 // provided by the system.
 933 const std::vector<std::pair<OUString, OUString>> aMetricCompatibleMap =
 934 {
 935     { "Times New Roman", "Liberation Serif" },
 936     { "Arial",           "Liberation Sans" },
 937     { "Arial Narrow",    "Liberation Sans Narrow" },
 938     { "Courier New",     "Liberation Mono" },
 939     { "Cambria",         "Caladea" },
 940     { "Calibri",         "Carlito" },
 941 };
 942
 943 static bool FindMetricCompatibleFont(FontSelectPattern& rFontSelData)
 944 {
 945     for (const auto& aSub : aMetricCompatibleMap)
 946     {
 947         if (rFontSelData.maSearchName == GetEnglishSearchFontName(aSub.first))
 948         {
 949             rFontSelData.maSearchName = aSub.second;
 950             return true;
 951         }
 952     }
 953
 954     return false;
 955 }
 956
 957 PhysicalFontFamily* PhysicalFontCollection::FindFontFamily(FontSelectPattern& rFSD) const
 958 {
 959     // give up if no fonts are available
 960     if( !Count() )
 961         return nullptr;
 962
 963     static bool noFontLookup = getenv("SAL_NO_FONT_LOOKUP") != nullptr;
 964     if (noFontLookup)
 965     {
 966         // Hard code the use of Liberation Sans and skip font search.
 967         sal_Int32 nIndex = 0;
 968         rFSD.maTargetName = GetNextFontToken(rFSD.GetFamilyName(), nIndex);
 969         rFSD.maSearchName = "liberationsans";
 970         PhysicalFontFamily* pFont = ImplFindFontFamilyBySearchName(rFSD.maSearchName);
 971         assert(pFont);
 972         return pFont;
 973     }
 974
 975     bool bMultiToken = false;
 976     sal_Int32 nTokenPos = 0;
 977     OUString& aSearchName = rFSD.maSearchName; // TODO: get rid of reference
 978     for(;;)
 979     {
 980         rFSD.maTargetName = GetNextFontToken( rFSD.GetFamilyName(), nTokenPos );
 981         aSearchName = rFSD.maTargetName;
 982
 983         // Until features are properly supported, they are appended to the
 984         // font name, so we need to strip them off so the font is found.
 985         sal_Int32 nFeat = aSearchName.indexOf(FontSelectPattern::FEAT_PREFIX);
 986         OUString aOrigName = rFSD.maTargetName;
 987         OUString aBaseFontName = aSearchName.copy( 0, (nFeat != -1) ? nFeat : aSearchName.getLength() );
 988
 989         if (nFeat != -1)
 990         {
 991             aSearchName = aBaseFontName;
 992             rFSD.maTargetName = aBaseFontName;
 993         }
 994
 995         aSearchName = GetEnglishSearchFontName( aSearchName );
 996         ImplFontSubstitute(aSearchName);
 997         // #114999# special emboldening for Ricoh fonts
 998         // TODO: smarter check for special cases by using PreMatch infrastructure?
 999         if( (rFSD.GetWeight() > WEIGHT_MEDIUM) &&
1000             aSearchName.startsWithIgnoreAsciiCase( "hg" ) )
1001         {
1002             OUString aBoldName;
1003             if( aSearchName.startsWithIgnoreAsciiCase( "hggothicb" ) )
1004                 aBoldName = "hggothice";
1005             else if( aSearchName.startsWithIgnoreAsciiCase( "hgpgothicb" ) )
1006                 aBoldName = "hgpgothice";
1007             else if( aSearchName.startsWithIgnoreAsciiCase( "hgminchol" ) )
1008                 aBoldName = "hgminchob";
1009             else if( aSearchName.startsWithIgnoreAsciiCase( "hgpminchol" ) )
1010                 aBoldName = "hgpminchob";
1011             else if( aSearchName.equalsIgnoreAsciiCase( "hgminchob" ) )
1012                 aBoldName = "hgminchoe";
1013             else if( aSearchName.equalsIgnoreAsciiCase( "hgpminchob" ) )
1014                 aBoldName = "hgpminchoe";
1015
1016             if( !aBoldName.isEmpty() && ImplFindFontFamilyBySearchName( aBoldName ) )
1017             {
1018                 // the other font is available => use it
1019                 aSearchName = aBoldName;
1020                 // prevent synthetic emboldening of bold version
1021                 rFSD.SetWeight(WEIGHT_DONTKNOW);
1022             }
1023         }
1024
1025         // restore the features to make the font selection data unique
1026         rFSD.maTargetName = aOrigName;
1027
1028         // check if the current font name token or its substitute is valid
1029         PhysicalFontFamily* pFoundData = ImplFindFontFamilyBySearchName(aSearchName);
1030         if( pFoundData )
1031             return pFoundData;
1032
1033         // some systems provide special customization
1034         // e.g. they suggest "serif" as UI-font, but this name cannot be used directly
1035         //      because the system wants to map it to another font first, e.g. "Helvetica"
1036
1037         // use the target name to search in the prematch hook
1038         rFSD.maTargetName = aBaseFontName;
1039
1040         // Related: fdo#49271 RTF files often contain weird-ass
1041         // Win 3.1/Win95 style fontnames which attempt to put the
1042         // charset encoding into the filename
1043         // http://www.webcenter.ru/~kazarn/eng/fonts_ttf.htm
1044         OUString sStrippedName = StripScriptFromName(rFSD.maTargetName);
1045         if (sStrippedName != rFSD.maTargetName)
1046         {
1047             rFSD.maTargetName = sStrippedName;
1048             aSearchName = GetEnglishSearchFontName(rFSD.maTargetName);
1049             pFoundData = ImplFindFontFamilyBySearchName(aSearchName);
1050             if( pFoundData )
1051                 return pFoundData;
1052         }
1053
1054         if (FindMetricCompatibleFont(rFSD) ||
1055             (mpPreMatchHook && mpPreMatchHook->FindFontSubstitute(rFSD)))
1056         {
1057             aSearchName = GetEnglishSearchFontName(aSearchName);
1058         }
1059
1060         // the prematch hook uses the target name to search, but we now need
1061         // to restore the features to make the font selection data unique
1062         rFSD.maTargetName = aOrigName;
1063
1064         pFoundData = ImplFindFontFamilyBySearchName( aSearchName );
1065         if( pFoundData )
1066             return pFoundData;
1067
1068         // break after last font name token was checked unsuccessfully
1069         if( nTokenPos == -1)
1070             break;
1071         bMultiToken = true;
1072     }
1073
1074     // if the first font was not available find the next available font in
1075     // the semicolon separated list of font names. A font is also considered
1076     // available when there is a matching entry in the Tools->Options->Fonts
1077     // dialog with neither ALWAYS nor SCREENONLY flags set and the substitution
1078     // font is available
1079     for( nTokenPos = 0; nTokenPos != -1; )
1080     {
1081         if( bMultiToken )
1082         {
1083             rFSD.maTargetName = GetNextFontToken( rFSD.GetFamilyName(), nTokenPos );
1084             aSearchName = GetEnglishSearchFontName( rFSD.maTargetName );
1085         }
1086         else
1087             nTokenPos = -1;
1088         if (FindMetricCompatibleFont(rFSD) ||
1089             (mpPreMatchHook && mpPreMatchHook->FindFontSubstitute(rFSD)))
1090         {
1091             aSearchName = GetEnglishSearchFontName( aSearchName );
1092         }
1093         ImplFontSubstitute(aSearchName);
1094         PhysicalFontFamily* pFoundData = ImplFindFontFamilyBySearchName(aSearchName);
1095         if( pFoundData )
1096             return pFoundData;
1097     }
1098
1099     // if no font with a directly matching name is available use the
1100     // first font name token and get its attributes to find a replacement
1101     if ( bMultiToken )
1102     {
1103         nTokenPos = 0;
1104         rFSD.maTargetName = GetNextFontToken( rFSD.GetFamilyName(), nTokenPos );
1105         aSearchName = GetEnglishSearchFontName( rFSD.maTargetName );
1106     }
1107
1108     OUString      aSearchShortName;
1109     OUString      aSearchFamilyName;
1110     FontWeight    eSearchWeight   = rFSD.GetWeight();
1111     FontWidth     eSearchWidth    = rFSD.GetWidthType();
1112     ImplFontAttrs nSearchType     = ImplFontAttrs::None;
1113     utl::FontSubstConfiguration::getMapName( aSearchName, aSearchShortName, aSearchFamilyName,
1114                                              eSearchWeight, eSearchWidth, nSearchType );
1115
1116     // note: the search name was already translated to english (if possible)
1117     // use the font's shortened name if needed
1118     if ( aSearchShortName != aSearchName )
1119     {
1120         PhysicalFontFamily* pFoundData = ImplFindFontFamilyBySearchName(aSearchShortName);
1121         if( pFoundData )
1122         {
1123 #ifdef UNX
1124             /* #96738# don't use mincho as a replacement for "MS Mincho" on X11: Mincho is
1125             a korean bitmap font that is not suitable here. Use the font replacement table,
1126             that automatically leads to the desired "HG Mincho Light J". Same story for
1127             MS Gothic, there are thai and korean "Gothic" fonts, so we even prefer Andale */
1128             if ((aSearchName != "msmincho") && (aSearchName != "msgothic"))
1129                 // TODO: add heuristic to only throw out the fake ms* fonts
1130 #endif
1131             {
1132                 return pFoundData;
1133             }
1134         }
1135     }
1136
1137     // use font fallback
1138     const utl::FontNameAttr* pFontAttr = nullptr;
1139     if (!aSearchName.isEmpty() && !comphelper::IsFuzzing())
1140     {
1141         // get fallback info using FontSubstConfiguration and
1142         // the target name, it's shortened name and family name in that order
1143         const utl::FontSubstConfiguration& rFontSubst = utl::FontSubstConfiguration::get();
1144         pFontAttr = rFontSubst.getSubstInfo( aSearchName );
1145         if ( !pFontAttr && (aSearchShortName != aSearchName) )
1146             pFontAttr = rFontSubst.getSubstInfo( aSearchShortName );
1147         if ( !pFontAttr && (aSearchFamilyName != aSearchShortName) )
1148             pFontAttr = rFontSubst.getSubstInfo( aSearchFamilyName );
1149
1150         // try the font substitutions suggested by the fallback info
1151         if( pFontAttr )
1152         {
1153             PhysicalFontFamily* pFoundData = ImplFindFontFamilyBySubstFontAttr(*pFontAttr);
1154             if( pFoundData )
1155                 return pFoundData;
1156         }
1157     }
1158
1159     // if a target symbol font is not available use a default symbol font
1160     if( rFSD.IsMicrosoftSymbolEncoded() )
1161     {
1162         LanguageTag aDefaultLanguageTag(u"en"_ustr);
1163         if (comphelper::IsFuzzing())
1164             aSearchName = "OpenSymbol";
1165         else
1166             aSearchName = utl::DefaultFontConfiguration::get().getDefaultFont( aDefaultLanguageTag, DefaultFontType::SYMBOL );
1167         PhysicalFontFamily* pFoundData = FindFontFamilyByTokenNames(aSearchName);
1168         if( pFoundData )
1169             return pFoundData;
1170     }
1171
1172     // now try the other font name tokens
1173     while( nTokenPos != -1 )
1174     {
1175         rFSD.maTargetName = GetNextFontToken( rFSD.GetFamilyName(), nTokenPos );
1176         if( rFSD.maTargetName.isEmpty() )
1177             continue;
1178
1179         aSearchName = GetEnglishSearchFontName( rFSD.maTargetName );
1180
1181         OUString      aTempShortName;
1182         OUString      aTempFamilyName;
1183         ImplFontAttrs nTempType   = ImplFontAttrs::None;
1184         FontWeight    eTempWeight = rFSD.GetWeight();
1185         FontWidth     eTempWidth  = WIDTH_DONTKNOW;
1186         utl::FontSubstConfiguration::getMapName( aSearchName, aTempShortName, aTempFamilyName,
1187                                                  eTempWeight, eTempWidth, nTempType );
1188
1189         // use a shortened token name if available
1190         if( aTempShortName != aSearchName )
1191         {
1192             PhysicalFontFamily* pFoundData = ImplFindFontFamilyBySearchName(aTempShortName);
1193             if( pFoundData )
1194                 return pFoundData;
1195         }
1196
1197         const utl::FontNameAttr* pTempFontAttr = nullptr;
1198         if (!comphelper::IsFuzzing())
1199         {
1200             // use a font name from font fallback list to determine font attributes
1201             // get fallback info using FontSubstConfiguration and
1202             // the target name, it's shortened name and family name in that order
1203             const utl::FontSubstConfiguration& rFontSubst = utl::FontSubstConfiguration::get();
1204             pTempFontAttr = rFontSubst.getSubstInfo( aSearchName );
1205
1206             if ( !pTempFontAttr && (aTempShortName != aSearchName) )
1207                 pTempFontAttr = rFontSubst.getSubstInfo( aTempShortName );
1208
1209             if ( !pTempFontAttr && (aTempFamilyName != aTempShortName) )
1210                 pTempFontAttr = rFontSubst.getSubstInfo( aTempFamilyName );
1211         }
1212
1213         // try the font substitutions suggested by the fallback info
1214         if( pTempFontAttr )
1215         {
1216             PhysicalFontFamily* pFoundData = ImplFindFontFamilyBySubstFontAttr(*pTempFontAttr);
1217             if( pFoundData )
1218                 return pFoundData;
1219             if( !pFontAttr )
1220                 pFontAttr = pTempFontAttr;
1221         }
1222     }
1223
1224     // if still needed use the font request's attributes to find a good match
1225     if (MsLangId::isSimplifiedChinese(rFSD.meLanguage))
1226         nSearchType |= ImplFontAttrs::CJK | ImplFontAttrs::CJK_SC;
1227     else if (MsLangId::isTraditionalChinese(rFSD.meLanguage))
1228         nSearchType |= ImplFontAttrs::CJK | ImplFontAttrs::CJK_TC;
1229     else if (MsLangId::isKorean(rFSD.meLanguage))
1230         nSearchType |= ImplFontAttrs::CJK | ImplFontAttrs::CJK_KR;
1231     else if (rFSD.meLanguage == LANGUAGE_JAPANESE)
1232         nSearchType |= ImplFontAttrs::CJK | ImplFontAttrs::CJK_JP;
1233     else
1234     {
1235         nSearchType |= lcl_IsCJKFont( rFSD.GetFamilyName() );
1236         if( rFSD.IsMicrosoftSymbolEncoded() )
1237             nSearchType |= ImplFontAttrs::Symbol;
1238     }
1239
1240     PhysicalFontFamily::CalcType(nSearchType, eSearchWeight, eSearchWidth, rFSD.GetFamilyType(), pFontAttr);
1241     PhysicalFontFamily* pFoundData = FindFontFamilyByAttributes(nSearchType,
1242         eSearchWeight, eSearchWidth, rFSD.GetItalic(), aSearchFamilyName);
1243
1244     if( pFoundData )
1245     {
1246         // overwrite font selection attributes using info from the typeface flags
1247         if ((eSearchWeight >= WEIGHT_BOLD)
1248             && (eSearchWeight > rFSD.GetWeight())
1249             && (pFoundData->GetTypeFaces() & FontTypeFaces::Bold))
1250         {
1251             rFSD.SetWeight( eSearchWeight );
1252         }
1253         else if ((eSearchWeight < WEIGHT_NORMAL)
1254                  && (eSearchWeight < rFSD.GetWeight())
1255                  && (eSearchWeight != WEIGHT_DONTKNOW)
1256                  && (pFoundData->GetTypeFaces() & FontTypeFaces::Light))
1257         {
1258             rFSD.SetWeight( eSearchWeight );
1259         }
1260
1261         if ((nSearchType & ImplFontAttrs::Italic)
1262             && ((rFSD.GetItalic() == ITALIC_DONTKNOW)
1263             || (rFSD.GetItalic() == ITALIC_NONE))
1264             && (pFoundData->GetTypeFaces() & FontTypeFaces::Italic))
1265         {
1266             rFSD.SetItalic( ITALIC_NORMAL );
1267         }
1268     }
1269     else
1270     {
1271         // if still needed fall back to default fonts
1272         pFoundData = ImplFindFontFamilyOfDefaultFont();
1273     }
1274
1275     return pFoundData;
1276 }
1277 }
1278
1279 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */