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