2 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <dali-toolkit/internal/text/multi-language-support-impl.h>
22 #include <dali/integration-api/debug.h>
23 #include <dali/devel-api/adaptor-framework/singleton-service.h>
24 #include <dali/devel-api/text-abstraction/font-client.h>
27 #include <dali-toolkit/internal/text/multi-language-helper-functions.h>
37 #if defined(DEBUG_ENABLED)
38 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_MULTI_LANGUAGE_SUPPORT");
41 const Dali::Toolkit::Text::Character UTF32_A = 0x0041;
50 bool ValidateFontsPerScript::IsValidFont( FontId fontId ) const
52 for( Vector<FontId>::ConstIterator it = mValidFonts.Begin(),
53 endIt = mValidFonts.End();
66 FontId DefaultFonts::FindFont( TextAbstraction::FontClient& fontClient,
67 const TextAbstraction::FontDescription& description,
68 PointSize26Dot6 size ) const
70 for( std::vector<CacheItem>::const_iterator it = mFonts.begin(),
75 const CacheItem& item = *it;
77 if( ( ( TextAbstraction::FontWeight::NONE == description.weight ) || ( description.weight == item.description.weight ) ) &&
78 ( ( TextAbstraction::FontWidth::NONE == description.width ) || ( description.width == item.description.width ) ) &&
79 ( ( TextAbstraction::FontSlant::NONE == description.slant ) || ( description.slant == item.description.slant ) ) &&
80 ( size == fontClient.GetPointSize( item.fontId ) ) &&
81 ( description.family.empty() || ( description.family == item.description.family ) ) )
90 void DefaultFonts::Cache( const TextAbstraction::FontDescription& description, FontId fontId )
93 item.description = description;
95 mFonts.push_back( item );
98 MultilanguageSupport::MultilanguageSupport()
99 : mDefaultFontPerScriptCache(),
100 mValidFontsPerScriptCache()
102 // Initializes the default font cache to zero (invalid font).
103 // Reserves space to cache the default fonts and access them with the script as an index.
104 mDefaultFontPerScriptCache.Resize( TextAbstraction::UNKNOWN + 1, NULL );
106 // Initializes the valid fonts cache to NULL (no valid fonts).
107 // Reserves space to cache the valid fonts and access them with the script as an index.
108 mValidFontsPerScriptCache.Resize( TextAbstraction::UNKNOWN + 1, NULL );
111 MultilanguageSupport::~MultilanguageSupport()
113 // Destroy the default font per script cache.
114 for( Vector<DefaultFonts*>::Iterator it = mDefaultFontPerScriptCache.Begin(),
115 endIt = mDefaultFontPerScriptCache.End();
122 // Destroy the valid fonts per script cache.
123 for( Vector<ValidateFontsPerScript*>::Iterator it = mValidFontsPerScriptCache.Begin(),
124 endIt = mValidFontsPerScriptCache.End();
132 Text::MultilanguageSupport MultilanguageSupport::Get()
134 Text::MultilanguageSupport multilanguageSupportHandle;
136 SingletonService service( SingletonService::Get() );
139 // Check whether the singleton is already created
140 Dali::BaseHandle handle = service.GetSingleton( typeid( Text::MultilanguageSupport ) );
143 // If so, downcast the handle
144 MultilanguageSupport* impl = dynamic_cast< Internal::MultilanguageSupport* >( handle.GetObjectPtr() );
145 multilanguageSupportHandle = Text::MultilanguageSupport( impl );
147 else // create and register the object
149 multilanguageSupportHandle = Text::MultilanguageSupport( new MultilanguageSupport );
150 service.Register( typeid( multilanguageSupportHandle ), multilanguageSupportHandle );
154 return multilanguageSupportHandle;
157 void MultilanguageSupport::SetScripts( const Vector<Character>& text,
158 CharacterIndex startIndex,
159 Length numberOfCharacters,
160 Vector<ScriptRun>& scripts )
162 if( 0u == numberOfCharacters )
164 // Nothing to do if there are no characters.
168 // Find the first index where to insert the script.
169 ScriptRunIndex scriptIndex = 0u;
170 if( 0u != startIndex )
172 for( Vector<ScriptRun>::ConstIterator it = scripts.Begin(),
173 endIt = scripts.End();
175 ++it, ++scriptIndex )
177 const ScriptRun& run = *it;
178 if( startIndex < run.characterRun.characterIndex + run.characterRun.numberOfCharacters )
186 // Stores the current script run.
187 ScriptRun currentScriptRun;
188 currentScriptRun.characterRun.characterIndex = startIndex;
189 currentScriptRun.characterRun.numberOfCharacters = 0u;
190 currentScriptRun.script = TextAbstraction::UNKNOWN;
192 // Reserve some space to reduce the number of reallocations.
193 scripts.Reserve( text.Count() << 2u );
195 // Whether the first valid script needs to be set.
196 bool isFirstScriptToBeSet = true;
198 // Whether the first valid script is a right to left script.
199 bool isParagraphRTL = false;
201 // Count the number of characters which are valid for all scripts. i.e. white spaces or '\n'.
202 Length numberOfAllScriptCharacters = 0u;
204 // Pointers to the text buffer.
205 const Character* const textBuffer = text.Begin();
207 // Traverse all characters and set the scripts.
208 const Length lastCharacter = startIndex + numberOfCharacters;
209 for( Length index = startIndex; index < lastCharacter; ++index )
211 Character character = *( textBuffer + index );
213 // Get the script of the character.
214 Script script = TextAbstraction::GetCharacterScript( character );
216 // Some characters (like white spaces) are valid for many scripts. The rules to set a script
218 // - If they are at the begining of a paragraph they get the script of the first character with
219 // a defined script. If they are at the end, they get the script of the last one.
220 // - If they are between two scripts with the same direction, they get the script of the previous
221 // character with a defined script. If the two scripts have different directions, they get the
222 // script of the first character of the paragraph with a defined script.
224 // Skip those characters valid for many scripts like white spaces or '\n'.
225 bool endOfText = index == lastCharacter;
227 ( TextAbstraction::COMMON == script ) )
229 if( TextAbstraction::EMOJI == currentScriptRun.script )
231 // Emojis doesn't mix well with characters common to all scripts. Insert the emoji run.
232 scripts.Insert( scripts.Begin() + scriptIndex, currentScriptRun );
235 // Initialize the new one.
236 currentScriptRun.characterRun.characterIndex = currentScriptRun.characterRun.characterIndex + currentScriptRun.characterRun.numberOfCharacters;
237 currentScriptRun.characterRun.numberOfCharacters = 0u;
238 currentScriptRun.script = TextAbstraction::UNKNOWN;
239 numberOfAllScriptCharacters = 0u;
242 // Count all these characters to be added into a script.
243 ++numberOfAllScriptCharacters;
245 if( TextAbstraction::IsNewParagraph( character ) )
247 // The character is a new paragraph.
248 // To know when there is a new paragraph is needed because if there is a white space
249 // between two scripts with different directions, it is added to the script with
250 // the same direction than the first script of the paragraph.
251 isFirstScriptToBeSet = true;
253 // Characters common to all scripts at the end of the paragraph are added to the last script.
254 currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
256 // Store the script run.
257 scripts.Insert( scripts.Begin() + scriptIndex, currentScriptRun );
260 // Initialize the new one.
261 currentScriptRun.characterRun.characterIndex = currentScriptRun.characterRun.characterIndex + currentScriptRun.characterRun.numberOfCharacters;
262 currentScriptRun.characterRun.numberOfCharacters = 0u;
263 currentScriptRun.script = TextAbstraction::UNKNOWN;
264 numberOfAllScriptCharacters = 0u;
267 // Get the next character.
269 endOfText = index == lastCharacter;
272 character = *( textBuffer + index );
273 script = TextAbstraction::GetCharacterScript( character );
275 } // end while( !endOfText && ( TextAbstraction::COMMON == script ) )
279 // Last characters of the text are 'white spaces'.
280 // There is nothing else to do. Just add the remaining characters to the last script after this bucle.
284 // Check if it is the first character of a paragraph.
285 if( isFirstScriptToBeSet &&
286 ( TextAbstraction::UNKNOWN != script ) &&
287 ( TextAbstraction::COMMON != script ) &&
288 ( TextAbstraction::EMOJI != script ) )
290 // Sets the direction of the first valid script.
291 isParagraphRTL = TextAbstraction::IsRightToLeftScript( script );
292 isFirstScriptToBeSet = false;
295 if( ( script != currentScriptRun.script ) &&
296 ( TextAbstraction::COMMON != script ) )
298 // Current run needs to be stored and a new one initialized.
300 if( ( isParagraphRTL == TextAbstraction::IsRightToLeftScript( currentScriptRun.script ) ) &&
301 ( TextAbstraction::UNKNOWN != currentScriptRun.script ) )
303 // Previous script has the same direction than the first script of the paragraph.
304 // All the previously skipped characters need to be added to the previous script before it's stored.
305 currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
306 numberOfAllScriptCharacters = 0u;
308 else if( ( TextAbstraction::IsRightToLeftScript( currentScriptRun.script ) == TextAbstraction::IsRightToLeftScript( script ) ) &&
309 ( TextAbstraction::UNKNOWN != currentScriptRun.script ) )
311 // Current script and previous one have the same direction.
312 // All the previously skipped characters need to be added to the previous script before it's stored.
313 currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
314 numberOfAllScriptCharacters = 0u;
316 else if( ( TextAbstraction::UNKNOWN == currentScriptRun.script ) &&
317 ( TextAbstraction::EMOJI == script ) )
319 currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
320 numberOfAllScriptCharacters = 0u;
323 if( 0u != currentScriptRun.characterRun.numberOfCharacters )
325 // Store the script run.
326 scripts.Insert( scripts.Begin() + scriptIndex, currentScriptRun );
330 // Initialize the new one.
331 currentScriptRun.characterRun.characterIndex = currentScriptRun.characterRun.characterIndex + currentScriptRun.characterRun.numberOfCharacters;
332 currentScriptRun.characterRun.numberOfCharacters = numberOfAllScriptCharacters + 1u; // Adds the white spaces which are at the begining of the script.
333 currentScriptRun.script = script;
334 numberOfAllScriptCharacters = 0u;
338 if( TextAbstraction::UNKNOWN != currentScriptRun.script )
340 // Adds white spaces between characters.
341 currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
342 numberOfAllScriptCharacters = 0u;
345 // Add one more character to the run.
346 ++currentScriptRun.characterRun.numberOfCharacters;
350 // Add remaining characters into the last script.
351 currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
353 if( 0u != currentScriptRun.characterRun.numberOfCharacters )
355 // Store the last run.
356 scripts.Insert( scripts.Begin() + scriptIndex, currentScriptRun );
360 if( scriptIndex < scripts.Count() )
362 // Update the indices of the next script runs.
363 const ScriptRun& run = *( scripts.Begin() + scriptIndex - 1u );
364 CharacterIndex nextCharacterIndex = run.characterRun.characterIndex + run.characterRun.numberOfCharacters;
366 for( Vector<ScriptRun>::Iterator it = scripts.Begin() + scriptIndex,
367 endIt = scripts.End();
371 ScriptRun& run = *it;
372 run.characterRun.characterIndex = nextCharacterIndex;
373 nextCharacterIndex += run.characterRun.numberOfCharacters;
378 void MultilanguageSupport::ValidateFonts( const Vector<Character>& text,
379 const Vector<ScriptRun>& scripts,
380 const Vector<FontDescriptionRun>& fontDescriptions,
381 const TextAbstraction::FontDescription& defaultFontDescription,
382 TextAbstraction::PointSize26Dot6 defaultFontPointSize,
383 CharacterIndex startIndex,
384 Length numberOfCharacters,
385 Vector<FontRun>& fonts )
387 DALI_LOG_INFO( gLogFilter, Debug::General, "-->MultilanguageSupport::ValidateFonts\n" );
389 if( 0u == numberOfCharacters )
391 DALI_LOG_INFO( gLogFilter, Debug::General, "<--MultilanguageSupport::ValidateFonts\n" );
392 // Nothing to do if there are no characters.
396 // Find the first index where to insert the font run.
397 FontRunIndex fontIndex = 0u;
398 if( 0u != startIndex )
400 for( Vector<FontRun>::ConstIterator it = fonts.Begin(),
405 const FontRun& run = *it;
406 if( startIndex < run.characterRun.characterIndex + run.characterRun.numberOfCharacters )
414 // Traverse the characters and validate/set the fonts.
417 DefaultFonts** defaultFontPerScriptCacheBuffer = mDefaultFontPerScriptCache.Begin();
418 ValidateFontsPerScript** validFontsPerScriptCacheBuffer = mValidFontsPerScriptCache.Begin();
420 // Stores the validated font runs.
421 fonts.Reserve( fontDescriptions.Count() );
423 // Initializes a validated font run.
424 FontRun currentFontRun;
425 currentFontRun.characterRun.characterIndex = startIndex;
426 currentFontRun.characterRun.numberOfCharacters = 0u;
427 currentFontRun.fontId = 0u;
429 // Get the font client.
430 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
432 const Character* const textBuffer = text.Begin();
434 // Iterators of the script runs.
435 Vector<ScriptRun>::ConstIterator scriptRunIt = scripts.Begin();
436 Vector<ScriptRun>::ConstIterator scriptRunEndIt = scripts.End();
437 bool isNewParagraphCharacter = false;
439 FontId currentFontId = 0u;
440 FontId previousFontId = 0u;
441 bool isPreviousEmojiScript = false;
443 // Description of fallback font which is selected at current iteration.
444 TextAbstraction::FontDescription selectedFontDescription;
446 CharacterIndex lastCharacter = startIndex + numberOfCharacters;
447 for( Length index = startIndex; index < lastCharacter; ++index )
449 // Get the current character.
450 const Character character = *( textBuffer + index );
451 bool needSoftwareBoldening = false;
452 bool needSoftwareItalic = false;
454 // new description for current character
455 TextAbstraction::FontDescription currentFontDescription;
456 TextAbstraction::PointSize26Dot6 currentFontPointSize = defaultFontPointSize;
457 bool isDefaultFont = true;
458 MergeFontDescriptions( fontDescriptions,
459 defaultFontDescription,
460 defaultFontPointSize,
462 currentFontDescription,
463 currentFontPointSize,
466 // Get the font for the current character.
467 FontId fontId = fontClient.GetFontId( currentFontDescription, currentFontPointSize );
468 currentFontId = fontId;
470 // Get the script for the current character.
471 Script script = GetScript( index,
477 Dali::TextAbstraction::FontDescription description;
478 fontClient.GetDescription( fontId, description );
480 DALI_LOG_INFO( gLogFilter,
482 " Initial font set\n Character : %x, Script : %s, Font : %s \n",
484 Dali::TextAbstraction::ScriptName[script],
485 description.path.c_str() );
489 // Validate whether the current character is supported by the given font.
490 bool isValidFont = false;
492 // Check first in the cache of default fonts per script and size.
494 FontId cachedDefaultFontId = 0u;
495 DefaultFonts* defaultFonts = *( defaultFontPerScriptCacheBuffer + script );
496 if( NULL != defaultFonts )
498 // This cache stores fall-back fonts.
499 cachedDefaultFontId = defaultFonts->FindFont( fontClient,
500 currentFontDescription,
501 currentFontPointSize );
504 // Whether the cached default font is valid.
505 const bool isValidCachedDefaultFont = 0u != cachedDefaultFontId;
507 // The font is valid if it matches with the default one for the current script and size and it's different than zero.
508 isValidFont = isValidCachedDefaultFont && ( fontId == cachedDefaultFontId );
512 // Check if the font supports the character.
513 isValidFont = fontClient.IsCharacterSupportedByFont( fontId, character );
516 bool isCommonScript = false;
517 bool isEmojiScript = TextAbstraction::EMOJI == script;
519 if( isEmojiScript && !isPreviousEmojiScript )
521 if( 0u != currentFontRun.characterRun.numberOfCharacters )
523 // Store the font run.
524 fonts.Insert( fonts.Begin() + fontIndex, currentFontRun );
528 // Initialize the new one.
529 currentFontRun.characterRun.characterIndex = currentFontRun.characterRun.characterIndex + currentFontRun.characterRun.numberOfCharacters;
530 currentFontRun.characterRun.numberOfCharacters = 0u;
531 currentFontRun.fontId = fontId;
534 // If the given font is not valid, it means either:
535 // - there is no cached font for the current script yet or,
536 // - the user has set a different font than the default one for the current script or,
537 // - the platform default font is different than the default font for the current script.
539 // Need to check if the given font supports the current character.
540 if( !isValidFont ) // (1)
542 // Whether the current character is common for all scripts (i.e. white spaces, ...)
544 // Is not desirable to cache fonts for the common script.
546 // i.e. Consider the text " हिंदी", the 'white space' has assigned the DEVANAGARI script.
547 // The user may have set a font or the platform's default is used.
549 // As the 'white space' is the first character, no font is cached so the font validation
550 // retrieves a glyph from the given font.
552 // Many fonts support 'white spaces' so probably the font set by the user or the platform's default
553 // supports the 'white space'. However, that font may not support the DEVANAGARI script.
554 isCommonScript = TextAbstraction::IsCommonScript( character );
558 if( isValidCachedDefaultFont &&
559 ( isDefaultFont || ( currentFontId == previousFontId ) ) &&
562 // At this point the character common for all scripts has no font assigned.
563 // If there is a valid previously cached default font for it, use that one.
564 fontId = cachedDefaultFontId;
569 // Check in the valid fonts cache.
570 ValidateFontsPerScript* validateFontsPerScript = *( validFontsPerScriptCacheBuffer + script );
572 if( NULL != validateFontsPerScript )
574 // This cache stores valid fonts set by the user.
575 isValidFont = validateFontsPerScript->IsValidFont( fontId );
577 // It may happen that a validated font for a script doesn't have all the glyphs for that script.
578 // i.e a font validated for the CJK script may contain glyphs for the chinese language but not for the Japanese.
581 // Checks if the current character is supported by the font is needed.
582 isValidFont = fontClient.IsCharacterSupportedByFont( fontId, character );
586 if( !isValidFont ) // (2)
588 // The selected font is not stored in any cache.
590 // Checks if the current character is supported by the selected font.
591 isValidFont = fontClient.IsCharacterSupportedByFont( fontId, character );
593 // Emojis are present in many monochrome fonts; prefer color by default.
597 const GlyphIndex glyphIndex = fontClient.GetGlyphIndex( fontId, character );
599 // For color emojis, the font is valid if the glyph is a color glyph (the bitmap is RGBA).
600 isValidFont = fontClient.IsColorGlyph( fontId, glyphIndex );
603 // If there is a valid font, cache it.
606 if( NULL == validateFontsPerScript )
608 validateFontsPerScript = new ValidateFontsPerScript();
610 *( validFontsPerScriptCacheBuffer + script ) = validateFontsPerScript;
613 validateFontsPerScript->mValidFonts.PushBack( fontId );
616 if( !isValidFont && ( fontId != cachedDefaultFontId ) ) // (3)
618 // The selected font by the user or the platform's default font has failed to validate the character.
620 // Checks if the previously discarted cached default font supports the character.
621 bool isValidCachedFont = false;
622 if( isValidCachedDefaultFont )
624 isValidCachedFont = fontClient.IsCharacterSupportedByFont( cachedDefaultFontId, character );
627 if( isValidCachedFont )
629 // Use the cached default font for the script if there is one.
630 fontId = cachedDefaultFontId;
634 // There is no valid cached default font for the script.
636 DefaultFonts* defaultFontsPerScript = NULL;
638 // Emojis are present in many monochrome fonts; prefer color by default.
639 const bool preferColor = ( TextAbstraction::EMOJI == script );
641 // Find a fallback-font.
642 fontId = fontClient.FindFallbackFont( character,
643 currentFontDescription,
644 currentFontPointSize,
649 // If the system does not support a suitable font, fallback to Latin
650 defaultFontsPerScript = *( defaultFontPerScriptCacheBuffer + TextAbstraction::LATIN );
651 if( NULL != defaultFontsPerScript )
653 fontId = defaultFontsPerScript->FindFont( fontClient,
654 currentFontDescription,
655 currentFontPointSize );
661 fontId = fontClient.FindDefaultFont( UTF32_A, currentFontPointSize );
664 if ( script != TextAbstraction::UNKNOWN )
666 // Cache the font if it is not an unknown script
667 if( NULL == defaultFontsPerScript )
669 defaultFontsPerScript = *( defaultFontPerScriptCacheBuffer + script );
671 if( NULL == defaultFontsPerScript )
673 defaultFontsPerScript = new DefaultFonts();
674 *( defaultFontPerScriptCacheBuffer + script ) = defaultFontsPerScript;
677 defaultFontsPerScript->Cache( currentFontDescription, fontId );
680 } // !isValidFont (3)
681 } // !isValidFont (2)
683 } // !isValidFont (1)
687 Dali::TextAbstraction::FontDescription description;
688 fontClient.GetDescription( fontId, description );
689 DALI_LOG_INFO( gLogFilter,
691 " Validated font set\n Character : %x, Script : %s, Font : %s \n",
693 Dali::TextAbstraction::ScriptName[script],
694 description.path.c_str() );
698 if( fontId != currentFontRun.fontId )
700 fontClient.GetDescription(fontId,selectedFontDescription);
703 // Developer sets bold to character but selected font cannot support it
704 needSoftwareBoldening = ( currentFontDescription.weight >= TextAbstraction::FontWeight::BOLD ) && ( selectedFontDescription.weight < TextAbstraction::FontWeight::BOLD );
706 // Developer sets italic to character but selected font cannot support it
707 needSoftwareItalic = ( currentFontDescription.slant == TextAbstraction::FontSlant::ITALIC ) && ( selectedFontDescription.slant < TextAbstraction::FontSlant::ITALIC );
709 // The font is now validated.
710 if( ( fontId != currentFontRun.fontId ) ||
711 isNewParagraphCharacter ||
712 // If font id is same as previous but style is diffrent, initialize new one
713 ( ( fontId == currentFontRun.fontId ) && ( ( needSoftwareBoldening != currentFontRun.softwareBold ) || ( needSoftwareItalic != currentFontRun.softwareItalic ) ) ) )
715 // Current run needs to be stored and a new one initialized.
717 if( 0u != currentFontRun.characterRun.numberOfCharacters )
719 // Store the font run.
720 fonts.Insert( fonts.Begin() + fontIndex, currentFontRun );
724 // Initialize the new one.
725 currentFontRun.characterRun.characterIndex = currentFontRun.characterRun.characterIndex + currentFontRun.characterRun.numberOfCharacters;
726 currentFontRun.characterRun.numberOfCharacters = 0u;
727 currentFontRun.fontId = fontId;
728 currentFontRun.softwareItalic = needSoftwareItalic;
729 currentFontRun.softwareBold = needSoftwareBoldening;
732 // Add one more character to the run.
733 ++currentFontRun.characterRun.numberOfCharacters;
735 // Whether the current character is a new paragraph character.
736 isNewParagraphCharacter = TextAbstraction::IsNewParagraph( character );
737 previousFontId = currentFontId;
738 isPreviousEmojiScript = isEmojiScript;
739 } // end traverse characters.
741 if( 0u != currentFontRun.characterRun.numberOfCharacters )
743 // Store the last run.
744 fonts.Insert( fonts.Begin() + fontIndex, currentFontRun );
748 if( fontIndex < fonts.Count() )
750 // Update the indices of the next font runs.
751 const FontRun& run = *( fonts.Begin() + fontIndex - 1u );
752 CharacterIndex nextCharacterIndex = run.characterRun.characterIndex + run.characterRun.numberOfCharacters;
754 for( Vector<FontRun>::Iterator it = fonts.Begin() + fontIndex,
761 run.characterRun.characterIndex = nextCharacterIndex;
762 nextCharacterIndex += run.characterRun.numberOfCharacters;
766 DALI_LOG_INFO( gLogFilter, Debug::General, "<--MultilanguageSupport::ValidateFonts\n" );
769 } // namespace Internal
773 } // namespace Toolkit