dali-toolkit/internal/text/multi-language-support-impl.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/text/multi-language-support-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/common/singleton-service.h>
  23 #include <dali/devel-api/text-abstraction/font-client.h>
  24 #include <dali/integration-api/debug.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/text/multi-language-helper-functions.h>
  28
  29 namespace Dali
  30 {
  31 namespace Toolkit
  32 {
  33 namespace
  34 {
  35 #if defined(DEBUG_ENABLED)
  36 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_MULTI_LANGUAGE_SUPPORT");
  37 #endif
  38
  39 const Dali::Toolkit::Text::Character UTF32_A = 0x0041;
  40 } // namespace
  41
  42 namespace Text
  43 {
  44 namespace Internal
  45 {
  46 bool ValidateFontsPerScript::IsValidFont(FontId fontId) const
  47 {
  48   for(Vector<FontId>::ConstIterator it    = mValidFonts.Begin(),
  49                                     endIt = mValidFonts.End();
  50       it != endIt;
  51       ++it)
  52   {
  53     if(fontId == *it)
  54     {
  55       return true;
  56     }
  57   }
  58
  59   return false;
  60 }
  61
  62 FontId DefaultFonts::FindFont(TextAbstraction::FontClient&            fontClient,
  63                               const TextAbstraction::FontDescription& description,
  64                               PointSize26Dot6                         size) const
  65 {
  66   for(std::vector<CacheItem>::const_iterator it    = mFonts.begin(),
  67                                              endIt = mFonts.end();
  68       it != endIt;
  69       ++it)
  70   {
  71     const CacheItem& item = *it;
  72
  73     if(((TextAbstraction::FontWeight::NONE == description.weight) || (description.weight == item.description.weight)) &&
  74        ((TextAbstraction::FontWidth::NONE == description.width) || (description.width == item.description.width)) &&
  75        ((TextAbstraction::FontSlant::NONE == description.slant) || (description.slant == item.description.slant)) &&
  76        (size == fontClient.GetPointSize(item.fontId)) &&
  77        (description.family.empty() || (description.family == item.description.family)))
  78     {
  79       return item.fontId;
  80     }
  81   }
  82
  83   return 0u;
  84 }
  85
  86 void DefaultFonts::Cache(const TextAbstraction::FontDescription& description, FontId fontId)
  87 {
  88   CacheItem item;
  89   item.description = description;
  90   item.fontId      = fontId;
  91   mFonts.push_back(item);
  92 }
  93
  94 MultilanguageSupport::MultilanguageSupport()
  95 : mDefaultFontPerScriptCache(),
  96   mValidFontsPerScriptCache()
  97 {
  98   // Initializes the default font cache to zero (invalid font).
  99   // Reserves space to cache the default fonts and access them with the script as an index.
 100   mDefaultFontPerScriptCache.Resize(TextAbstraction::UNKNOWN + 1, NULL);
 101
 102   // Initializes the valid fonts cache to NULL (no valid fonts).
 103   // Reserves space to cache the valid fonts and access them with the script as an index.
 104   mValidFontsPerScriptCache.Resize(TextAbstraction::UNKNOWN + 1, NULL);
 105 }
 106
 107 MultilanguageSupport::~MultilanguageSupport()
 108 {
 109   // Destroy the default font per script cache.
 110   for(Vector<DefaultFonts*>::Iterator it    = mDefaultFontPerScriptCache.Begin(),
 111                                       endIt = mDefaultFontPerScriptCache.End();
 112       it != endIt;
 113       ++it)
 114   {
 115     delete *it;
 116   }
 117
 118   // Destroy the valid fonts per script cache.
 119   for(Vector<ValidateFontsPerScript*>::Iterator it    = mValidFontsPerScriptCache.Begin(),
 120                                                 endIt = mValidFontsPerScriptCache.End();
 121       it != endIt;
 122       ++it)
 123   {
 124     delete *it;
 125   }
 126 }
 127
 128 Text::MultilanguageSupport MultilanguageSupport::Get()
 129 {
 130   Text::MultilanguageSupport multilanguageSupportHandle;
 131
 132   SingletonService service(SingletonService::Get());
 133   if(service)
 134   {
 135     // Check whether the singleton is already created
 136     Dali::BaseHandle handle = service.GetSingleton(typeid(Text::MultilanguageSupport));
 137     if(handle)
 138     {
 139       // If so, downcast the handle
 140       MultilanguageSupport* impl = dynamic_cast<Internal::MultilanguageSupport*>(handle.GetObjectPtr());
 141       multilanguageSupportHandle = Text::MultilanguageSupport(impl);
 142     }
 143     else // create and register the object
 144     {
 145       multilanguageSupportHandle = Text::MultilanguageSupport(new MultilanguageSupport);
 146       service.Register(typeid(multilanguageSupportHandle), multilanguageSupportHandle);
 147     }
 148   }
 149
 150   return multilanguageSupportHandle;
 151 }
 152
 153 void MultilanguageSupport::SetScripts(const Vector<Character>& text,
 154                                       CharacterIndex           startIndex,
 155                                       Length                   numberOfCharacters,
 156                                       Vector<ScriptRun>&       scripts)
 157 {
 158   if(0u == numberOfCharacters)
 159   {
 160     // Nothing to do if there are no characters.
 161     return;
 162   }
 163
 164   // Find the first index where to insert the script.
 165   ScriptRunIndex scriptIndex = 0u;
 166   if(0u != startIndex)
 167   {
 168     for(Vector<ScriptRun>::ConstIterator it    = scripts.Begin(),
 169                                          endIt = scripts.End();
 170         it != endIt;
 171         ++it, ++scriptIndex)
 172     {
 173       const ScriptRun& run = *it;
 174       if(startIndex < run.characterRun.characterIndex + run.characterRun.numberOfCharacters)
 175       {
 176         // Run found.
 177         break;
 178       }
 179     }
 180   }
 181
 182   // Stores the current script run.
 183   ScriptRun currentScriptRun;
 184   currentScriptRun.characterRun.characterIndex     = startIndex;
 185   currentScriptRun.characterRun.numberOfCharacters = 0u;
 186   currentScriptRun.script                          = TextAbstraction::UNKNOWN;
 187
 188   // Reserve some space to reduce the number of reallocations.
 189   scripts.Reserve(text.Count() << 2u);
 190
 191   // Whether the first valid script needs to be set.
 192   bool isFirstScriptToBeSet = true;
 193
 194   // Whether the first valid script is a right to left script.
 195   bool isParagraphRTL = false;
 196
 197   // Count the number of characters which are valid for all scripts. i.e. white spaces or '\n'.
 198   Length numberOfAllScriptCharacters = 0u;
 199
 200   // Pointers to the text buffer.
 201   const Character* const textBuffer = text.Begin();
 202
 203   // Initialize whether is right to left direction
 204   currentScriptRun.isRightToLeft = false;
 205
 206   // Traverse all characters and set the scripts.
 207   const Length lastCharacter = startIndex + numberOfCharacters;
 208   for(Length index = startIndex; index < lastCharacter; ++index)
 209   {
 210     Character character = *(textBuffer + index);
 211
 212     // Get the script of the character.
 213     Script script = TextAbstraction::GetCharacterScript(character);
 214
 215     // Some characters (like white spaces) are valid for many scripts. The rules to set a script
 216     // for them are:
 217     // - If they are at the begining of a paragraph they get the script of the first character with
 218     //   a defined script. If they are at the end, they get the script of the last one.
 219     // - If they are between two scripts with the same direction, they get the script of the previous
 220     //   character with a defined script. If the two scripts have different directions, they get the
 221     //   script of the first character of the paragraph with a defined script.
 222
 223     // Skip those characters valid for many scripts like white spaces or '\n'.
 224     bool endOfText = index == lastCharacter;
 225     while(!endOfText &&
 226           (TextAbstraction::COMMON == script))
 227     {
 228       // Check if whether is right to left markup and Keeps true if the previous value was true.
 229       currentScriptRun.isRightToLeft = currentScriptRun.isRightToLeft || TextAbstraction::IsRightToLeftMark(character);
 230
 231       // ZWJ, ZWNJ between emojis should be treated as EMOJI.
 232       if(TextAbstraction::EMOJI == currentScriptRun.script && !(TextAbstraction::IsZeroWidthJoiner(character) || TextAbstraction::IsZeroWidthNonJoiner(character)))
 233       {
 234         // Emojis doesn't mix well with characters common to all scripts. Insert the emoji run.
 235         scripts.Insert(scripts.Begin() + scriptIndex, currentScriptRun);
 236         ++scriptIndex;
 237
 238         // Initialize the new one.
 239         currentScriptRun.characterRun.characterIndex     = currentScriptRun.characterRun.characterIndex + currentScriptRun.characterRun.numberOfCharacters;
 240         currentScriptRun.characterRun.numberOfCharacters = 0u;
 241         currentScriptRun.script                          = TextAbstraction::UNKNOWN;
 242         numberOfAllScriptCharacters                      = 0u;
 243       }
 244
 245       // Count all these characters to be added into a script.
 246       ++numberOfAllScriptCharacters;
 247
 248       if(TextAbstraction::IsNewParagraph(character))
 249       {
 250         // The character is a new paragraph.
 251         // To know when there is a new paragraph is needed because if there is a white space
 252         // between two scripts with different directions, it is added to the script with
 253         // the same direction than the first script of the paragraph.
 254         isFirstScriptToBeSet = true;
 255
 256         // Characters common to all scripts at the end of the paragraph are added to the last script.
 257         currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
 258
 259         // Store the script run.
 260         scripts.Insert(scripts.Begin() + scriptIndex, currentScriptRun);
 261         ++scriptIndex;
 262
 263         // Initialize the new one.
 264         currentScriptRun.characterRun.characterIndex     = currentScriptRun.characterRun.characterIndex + currentScriptRun.characterRun.numberOfCharacters;
 265         currentScriptRun.characterRun.numberOfCharacters = 0u;
 266         currentScriptRun.script                          = TextAbstraction::UNKNOWN;
 267         numberOfAllScriptCharacters                      = 0u;
 268         // Initialize whether is right to left direction
 269         currentScriptRun.isRightToLeft = false;
 270       }
 271
 272       // Get the next character.
 273       ++index;
 274       endOfText = index == lastCharacter;
 275       if(!endOfText)
 276       {
 277         character = *(textBuffer + index);
 278         script    = TextAbstraction::GetCharacterScript(character);
 279       }
 280     } // end while( !endOfText && ( TextAbstraction::COMMON == script ) )
 281
 282     if(endOfText)
 283     {
 284       // Last characters of the text are 'white spaces'.
 285       // There is nothing else to do. Just add the remaining characters to the last script after this bucle.
 286       break;
 287     }
 288
 289     // Check if it is the first character of a paragraph.
 290     if(isFirstScriptToBeSet &&
 291        (TextAbstraction::UNKNOWN != script) &&
 292        (TextAbstraction::COMMON != script) &&
 293        (TextAbstraction::EMOJI != script))
 294     {
 295       // Sets the direction of the first valid script.
 296       isParagraphRTL       = currentScriptRun.isRightToLeft || TextAbstraction::IsRightToLeftScript(script);
 297       isFirstScriptToBeSet = false;
 298     }
 299
 300     if((script != currentScriptRun.script) &&
 301        (TextAbstraction::COMMON != script))
 302     {
 303       // Current run needs to be stored and a new one initialized.
 304
 305       if((isParagraphRTL == TextAbstraction::IsRightToLeftScript(currentScriptRun.script)) &&
 306          (TextAbstraction::UNKNOWN != currentScriptRun.script))
 307       {
 308         // Previous script has the same direction than the first script of the paragraph.
 309         // All the previously skipped characters need to be added to the previous script before it's stored.
 310         currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
 311         numberOfAllScriptCharacters = 0u;
 312       }
 313       else if((TextAbstraction::IsRightToLeftScript(currentScriptRun.script) == TextAbstraction::IsRightToLeftScript(script)) &&
 314               (TextAbstraction::UNKNOWN != currentScriptRun.script))
 315       {
 316         // Current script and previous one have the same direction.
 317         // All the previously skipped characters need to be added to the previous script before it's stored.
 318         currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
 319         numberOfAllScriptCharacters = 0u;
 320       }
 321       else if((TextAbstraction::UNKNOWN == currentScriptRun.script) &&
 322               (TextAbstraction::EMOJI == script))
 323       {
 324         currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
 325         numberOfAllScriptCharacters = 0u;
 326       }
 327
 328       if(0u != currentScriptRun.characterRun.numberOfCharacters)
 329       {
 330         // Store the script run.
 331         scripts.Insert(scripts.Begin() + scriptIndex, currentScriptRun);
 332         ++scriptIndex;
 333       }
 334
 335       // Initialize the new one.
 336       currentScriptRun.characterRun.characterIndex     = currentScriptRun.characterRun.characterIndex + currentScriptRun.characterRun.numberOfCharacters;
 337       currentScriptRun.characterRun.numberOfCharacters = numberOfAllScriptCharacters + 1u; // Adds the white spaces which are at the begining of the script.
 338       currentScriptRun.script                          = script;
 339       numberOfAllScriptCharacters                      = 0u;
 340       // Check if whether is right to left script.
 341       currentScriptRun.isRightToLeft = TextAbstraction::IsRightToLeftScript(currentScriptRun.script);
 342     }
 343     else
 344     {
 345       if(TextAbstraction::UNKNOWN != currentScriptRun.script)
 346       {
 347         // Adds white spaces between characters.
 348         currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
 349         numberOfAllScriptCharacters = 0u;
 350       }
 351
 352       // Add one more character to the run.
 353       ++currentScriptRun.characterRun.numberOfCharacters;
 354     }
 355   }
 356
 357   // Add remaining characters into the last script.
 358   currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
 359
 360   if(0u != currentScriptRun.characterRun.numberOfCharacters)
 361   {
 362     // Store the last run.
 363     scripts.Insert(scripts.Begin() + scriptIndex, currentScriptRun);
 364     ++scriptIndex;
 365   }
 366
 367   if(scriptIndex < scripts.Count())
 368   {
 369     // Update the indices of the next script runs.
 370     const ScriptRun& run                = *(scripts.Begin() + scriptIndex - 1u);
 371     CharacterIndex   nextCharacterIndex = run.characterRun.characterIndex + run.characterRun.numberOfCharacters;
 372
 373     for(Vector<ScriptRun>::Iterator it    = scripts.Begin() + scriptIndex,
 374                                     endIt = scripts.End();
 375         it != endIt;
 376         ++it)
 377     {
 378       ScriptRun& run                  = *it;
 379       run.characterRun.characterIndex = nextCharacterIndex;
 380       nextCharacterIndex += run.characterRun.numberOfCharacters;
 381     }
 382   }
 383 }
 384
 385 void MultilanguageSupport::ValidateFonts(const Vector<Character>&                text,
 386                                          const Vector<ScriptRun>&                scripts,
 387                                          const Vector<FontDescriptionRun>&       fontDescriptions,
 388                                          const TextAbstraction::FontDescription& defaultFontDescription,
 389                                          TextAbstraction::PointSize26Dot6        defaultFontPointSize,
 390                                          CharacterIndex                          startIndex,
 391                                          Length                                  numberOfCharacters,
 392                                          Vector<FontRun>&                        fonts)
 393 {
 394   DALI_LOG_INFO(gLogFilter, Debug::General, "-->MultilanguageSupport::ValidateFonts\n");
 395
 396   if(0u == numberOfCharacters)
 397   {
 398     DALI_LOG_INFO(gLogFilter, Debug::General, "<--MultilanguageSupport::ValidateFonts\n");
 399     // Nothing to do if there are no characters.
 400     return;
 401   }
 402
 403   // Find the first index where to insert the font run.
 404   FontRunIndex fontIndex = 0u;
 405   if(0u != startIndex)
 406   {
 407     for(Vector<FontRun>::ConstIterator it    = fonts.Begin(),
 408                                        endIt = fonts.End();
 409         it != endIt;
 410         ++it, ++fontIndex)
 411     {
 412       const FontRun& run = *it;
 413       if(startIndex < run.characterRun.characterIndex + run.characterRun.numberOfCharacters)
 414       {
 415         // Run found.
 416         break;
 417       }
 418     }
 419   }
 420
 421   // Traverse the characters and validate/set the fonts.
 422
 423   // Get the caches.
 424   DefaultFonts**           defaultFontPerScriptCacheBuffer = mDefaultFontPerScriptCache.Begin();
 425   ValidateFontsPerScript** validFontsPerScriptCacheBuffer  = mValidFontsPerScriptCache.Begin();
 426
 427   // Stores the validated font runs.
 428   fonts.Reserve(fontDescriptions.Count());
 429
 430   // Initializes a validated font run.
 431   FontRun currentFontRun;
 432   currentFontRun.characterRun.characterIndex     = startIndex;
 433   currentFontRun.characterRun.numberOfCharacters = 0u;
 434   currentFontRun.fontId                          = 0u;
 435   currentFontRun.isBoldRequired                  = false;
 436   currentFontRun.isItalicRequired                = false;
 437
 438   // Get the font client.
 439   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 440
 441   const Character* const textBuffer = text.Begin();
 442
 443   // Iterators of the script runs.
 444   Vector<ScriptRun>::ConstIterator scriptRunIt             = scripts.Begin();
 445   Vector<ScriptRun>::ConstIterator scriptRunEndIt          = scripts.End();
 446   bool                             isNewParagraphCharacter = false;
 447
 448   bool   isPreviousEmojiScript = false;
 449   FontId previousEmojiFontId   = 0u;
 450
 451   CharacterIndex lastCharacter = startIndex + numberOfCharacters;
 452   for(Length index = startIndex; index < lastCharacter; ++index)
 453   {
 454     // Get the current character.
 455     const Character character        = *(textBuffer + index);
 456     bool            isItalicRequired = false;
 457     bool            isBoldRequired   = false;
 458
 459     // new description for current character
 460     TextAbstraction::FontDescription currentFontDescription;
 461     TextAbstraction::PointSize26Dot6 currentFontPointSize = defaultFontPointSize;
 462     bool                             isDefaultFont        = true;
 463     MergeFontDescriptions(fontDescriptions,
 464                           defaultFontDescription,
 465                           defaultFontPointSize,
 466                           index,
 467                           currentFontDescription,
 468                           currentFontPointSize,
 469                           isDefaultFont);
 470
 471     // Get the font for the current character.
 472     FontId fontId = fontClient.GetFontId(currentFontDescription, currentFontPointSize);
 473
 474     // Get the script for the current character.
 475     Script script = GetScript(index,
 476                               scriptRunIt,
 477                               scriptRunEndIt);
 478
 479 #ifdef DEBUG_ENABLED
 480     {
 481       Dali::TextAbstraction::FontDescription description;
 482       fontClient.GetDescription(fontId, description);
 483
 484       DALI_LOG_INFO(gLogFilter,
 485                     Debug::Verbose,
 486                     "  Initial font set\n  Character : %x, Script : %s, Font : %s \n",
 487                     character,
 488                     Dali::TextAbstraction::ScriptName[script],
 489                     description.path.c_str());
 490     }
 491 #endif
 492
 493     // Validate whether the current character is supported by the given font.
 494     bool isValidFont = false;
 495
 496     // Check first in the cache of default fonts per script and size.
 497
 498     FontId        cachedDefaultFontId = 0u;
 499     DefaultFonts* defaultFonts        = *(defaultFontPerScriptCacheBuffer + script);
 500     if(NULL != defaultFonts)
 501     {
 502       // This cache stores fall-back fonts.
 503       cachedDefaultFontId = defaultFonts->FindFont(fontClient,
 504                                                    currentFontDescription,
 505                                                    currentFontPointSize);
 506     }
 507
 508     // Whether the cached default font is valid.
 509     const bool isValidCachedDefaultFont = 0u != cachedDefaultFontId;
 510
 511     // The font is valid if it matches with the default one for the current script and size and it's different than zero.
 512     isValidFont = isValidCachedDefaultFont && (fontId == cachedDefaultFontId);
 513
 514     if(isValidFont)
 515     {
 516       // Check if the font supports the character.
 517       isValidFont = fontClient.IsCharacterSupportedByFont(fontId, character);
 518     }
 519
 520     bool isCommonScript = false;
 521     bool isEmojiScript  = TextAbstraction::EMOJI == script;
 522
 523     if(isEmojiScript && !isPreviousEmojiScript)
 524     {
 525       if(0u != currentFontRun.characterRun.numberOfCharacters)
 526       {
 527         // Store the font run.
 528         fonts.Insert(fonts.Begin() + fontIndex, currentFontRun);
 529         ++fontIndex;
 530       }
 531
 532       // Initialize the new one.
 533       currentFontRun.characterRun.characterIndex     = currentFontRun.characterRun.characterIndex + currentFontRun.characterRun.numberOfCharacters;
 534       currentFontRun.characterRun.numberOfCharacters = 0u;
 535       currentFontRun.fontId                          = fontId;
 536       currentFontRun.isItalicRequired                = false;
 537       currentFontRun.isBoldRequired                  = false;
 538     }
 539
 540     // ZWJ, ZWNJ between emojis should use the previous emoji font.
 541     if(isEmojiScript && (TextAbstraction::IsZeroWidthJoiner(character) || TextAbstraction::IsZeroWidthNonJoiner(character)))
 542     {
 543       if(0u != previousEmojiFontId)
 544       {
 545         fontId      = previousEmojiFontId;
 546         isValidFont = true;
 547       }
 548     }
 549
 550     // If the given font is not valid, it means either:
 551     // - there is no cached font for the current script yet or,
 552     // - the user has set a different font than the default one for the current script or,
 553     // - the platform default font is different than the default font for the current script.
 554
 555     // Need to check if the given font supports the current character.
 556     if(!isValidFont) // (1)
 557     {
 558       // Whether the current character is common for all scripts (i.e. white spaces, ...)
 559
 560       // Is not desirable to cache fonts for the common script.
 561       //
 562       // i.e. Consider the text " हिंदी", the 'white space' has assigned the DEVANAGARI script.
 563       //      The user may have set a font or the platform's default is used.
 564       //
 565       //      As the 'white space' is the first character, no font is cached so the font validation
 566       //      retrieves a glyph from the given font.
 567       //
 568       //      Many fonts support 'white spaces' so probably the font set by the user or the platform's default
 569       //      supports the 'white space'. However, that font may not support the DEVANAGARI script.
 570       isCommonScript = TextAbstraction::IsCommonScript(character);
 571
 572       // Check in the valid fonts cache.
 573       ValidateFontsPerScript* validateFontsPerScript = *(validFontsPerScriptCacheBuffer + script);
 574
 575       if(NULL != validateFontsPerScript)
 576       {
 577         // This cache stores valid fonts set by the user.
 578         isValidFont = validateFontsPerScript->IsValidFont(fontId);
 579
 580         // It may happen that a validated font for a script doesn't have all the glyphs for that script.
 581         // i.e a font validated for the CJK script may contain glyphs for the chinese language but not for the Japanese.
 582         if(isValidFont)
 583         {
 584           // Checks if the current character is supported by the font is needed.
 585           isValidFont = fontClient.IsCharacterSupportedByFont(fontId, character);
 586         }
 587       }
 588
 589       if(!isValidFont) // (2)
 590       {
 591         // The selected font is not stored in any cache.
 592
 593         // Checks if the current character is supported by the selected font.
 594         isValidFont = fontClient.IsCharacterSupportedByFont(fontId, character);
 595
 596         // If there is a valid font, cache it.
 597         if(isValidFont && !isCommonScript)
 598         {
 599           if(NULL == validateFontsPerScript)
 600           {
 601             validateFontsPerScript = new ValidateFontsPerScript();
 602
 603             *(validFontsPerScriptCacheBuffer + script) = validateFontsPerScript;
 604           }
 605
 606           validateFontsPerScript->mValidFonts.PushBack(fontId);
 607         }
 608
 609         if(!isValidFont && (fontId != cachedDefaultFontId) && (!TextAbstraction::IsNewParagraph(character))) // (3)
 610         {
 611           // The selected font by the user or the platform's default font has failed to validate the character.
 612
 613           // Checks if the previously discarted cached default font supports the character.
 614           bool isValidCachedFont = false;
 615           if(isValidCachedDefaultFont)
 616           {
 617             isValidCachedFont = fontClient.IsCharacterSupportedByFont(cachedDefaultFontId, character);
 618           }
 619
 620           if(isValidCachedFont)
 621           {
 622             // Use the cached default font for the script if there is one.
 623             fontId = cachedDefaultFontId;
 624           }
 625           else
 626           {
 627             // There is no valid cached default font for the script.
 628
 629             DefaultFonts* defaultFontsPerScript = NULL;
 630
 631             // Find a fallback-font.
 632             fontId = fontClient.FindFallbackFont(character,
 633                                                  currentFontDescription,
 634                                                  currentFontPointSize,
 635                                                  false);
 636
 637             if(0u == fontId)
 638             {
 639               fontId = fontClient.FindDefaultFont(UTF32_A, currentFontPointSize);
 640             }
 641
 642             if(!isCommonScript && (script != TextAbstraction::UNKNOWN))
 643             {
 644               // Cache the font if it is not an unknown script
 645               if(NULL == defaultFontsPerScript)
 646               {
 647                 defaultFontsPerScript = *(defaultFontPerScriptCacheBuffer + script);
 648
 649                 if(NULL == defaultFontsPerScript)
 650                 {
 651                   defaultFontsPerScript                       = new DefaultFonts();
 652                   *(defaultFontPerScriptCacheBuffer + script) = defaultFontsPerScript;
 653                 }
 654               }
 655               defaultFontsPerScript->Cache(currentFontDescription, fontId);
 656             }
 657           }
 658         } // !isValidFont (3)
 659       }   // !isValidFont (2)
 660     }     // !isValidFont (1)
 661
 662     // Store the font id when the first character is an emoji.
 663     if(isEmojiScript && !isPreviousEmojiScript)
 664     {
 665       if(0u != fontId)
 666       {
 667         previousEmojiFontId = fontId;
 668       }
 669     }
 670
 671 #ifdef DEBUG_ENABLED
 672     {
 673       Dali::TextAbstraction::FontDescription description;
 674       fontClient.GetDescription(fontId, description);
 675       DALI_LOG_INFO(gLogFilter,
 676                     Debug::Verbose,
 677                     "  Validated font set\n  Character : %x, Script : %s, Font : %s \n",
 678                     character,
 679                     Dali::TextAbstraction::ScriptName[script],
 680                     description.path.c_str());
 681     }
 682 #endif
 683
 684     // Whether bols style is required.
 685     isBoldRequired = (currentFontDescription.weight >= TextAbstraction::FontWeight::BOLD);
 686
 687     // Whether italic style is required.
 688     isItalicRequired = (currentFontDescription.slant >= TextAbstraction::FontSlant::ITALIC);
 689
 690     // The font is now validated.
 691     if((fontId != currentFontRun.fontId) ||
 692        isNewParagraphCharacter ||
 693        // If font id is same as previous but style is diffrent, initialize new one
 694        ((fontId == currentFontRun.fontId) && ((isBoldRequired != currentFontRun.isBoldRequired) || (isItalicRequired != currentFontRun.isItalicRequired))))
 695     {
 696       // Current run needs to be stored and a new one initialized.
 697
 698       if(0u != currentFontRun.characterRun.numberOfCharacters)
 699       {
 700         // Store the font run.
 701         fonts.Insert(fonts.Begin() + fontIndex, currentFontRun);
 702         ++fontIndex;
 703       }
 704
 705       // Initialize the new one.
 706       currentFontRun.characterRun.characterIndex     = currentFontRun.characterRun.characterIndex + currentFontRun.characterRun.numberOfCharacters;
 707       currentFontRun.characterRun.numberOfCharacters = 0u;
 708       currentFontRun.fontId                          = fontId;
 709       currentFontRun.isBoldRequired                  = isBoldRequired;
 710       currentFontRun.isItalicRequired                = isItalicRequired;
 711     }
 712
 713     // Add one more character to the run.
 714     ++currentFontRun.characterRun.numberOfCharacters;
 715
 716     // Whether the current character is a new paragraph character.
 717     isNewParagraphCharacter = TextAbstraction::IsNewParagraph(character);
 718     isPreviousEmojiScript   = isEmojiScript;
 719   } // end traverse characters.
 720
 721   if(0u != currentFontRun.characterRun.numberOfCharacters)
 722   {
 723     // Store the last run.
 724     fonts.Insert(fonts.Begin() + fontIndex, currentFontRun);
 725     ++fontIndex;
 726   }
 727
 728   if(fontIndex < fonts.Count())
 729   {
 730     // Update the indices of the next font runs.
 731     const FontRun& run                = *(fonts.Begin() + fontIndex - 1u);
 732     CharacterIndex nextCharacterIndex = run.characterRun.characterIndex + run.characterRun.numberOfCharacters;
 733
 734     for(Vector<FontRun>::Iterator it    = fonts.Begin() + fontIndex,
 735                                   endIt = fonts.End();
 736         it != endIt;
 737         ++it)
 738     {
 739       FontRun& run = *it;
 740
 741       run.characterRun.characterIndex = nextCharacterIndex;
 742       nextCharacterIndex += run.characterRun.numberOfCharacters;
 743     }
 744   }
 745
 746   DALI_LOG_INFO(gLogFilter, Debug::General, "<--MultilanguageSupport::ValidateFonts\n");
 747 }
 748
 749 } // namespace Internal
 750
 751 } // namespace Text
 752
 753 } // namespace Toolkit
 754
 755 } // namespace Dali