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