/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
return false;
}
-FontId DefaultFonts::FindFont( TextAbstraction::FontClient& fontClient, PointSize26Dot6 size ) const
+FontId DefaultFonts::FindFont( TextAbstraction::FontClient& fontClient,
+ const TextAbstraction::FontDescription& description,
+ PointSize26Dot6 size ) const
{
- for( Vector<FontId>::ConstIterator it = mFonts.Begin(),
- endIt = mFonts.End();
+ for( std::vector<CacheItem>::const_iterator it = mFonts.begin(),
+ endIt = mFonts.end();
it != endIt;
++it )
{
- const FontId fontId = *it;
- if( size == fontClient.GetPointSize( fontId ) )
+ const CacheItem& item = *it;
+
+ if( ( ( TextAbstraction::FontWeight::NONE == description.weight ) || ( description.weight == item.description.weight ) ) &&
+ ( ( TextAbstraction::FontWidth::NONE == description.width ) || ( description.width == item.description.width ) ) &&
+ ( ( TextAbstraction::FontSlant::NONE == description.slant ) || ( description.slant == item.description.slant ) ) &&
+ ( size == fontClient.GetPointSize( item.fontId ) ) &&
+ ( description.family.empty() || ( description.family == item.description.family ) ) )
{
- return fontId;
+ return item.fontId;
}
}
return 0u;
}
+void DefaultFonts::Cache( const TextAbstraction::FontDescription& description, FontId fontId )
+{
+ CacheItem item;
+ item.description = description;
+ item.fontId = fontId;
+ mFonts.push_back( item );
+}
+
MultilanguageSupport::MultilanguageSupport()
: mDefaultFontPerScriptCache(),
mValidFontsPerScriptCache()
{
// Initializes the default font cache to zero (invalid font).
// Reserves space to cache the default fonts and access them with the script as an index.
- mDefaultFontPerScriptCache.Resize( TextAbstraction::UNKNOWN, NULL );
+ mDefaultFontPerScriptCache.Resize( TextAbstraction::UNKNOWN + 1, NULL );
// Initializes the valid fonts cache to NULL (no valid fonts).
// Reserves space to cache the valid fonts and access them with the script as an index.
- mValidFontsPerScriptCache.Resize( TextAbstraction::UNKNOWN, NULL );
+ mValidFontsPerScriptCache.Resize( TextAbstraction::UNKNOWN + 1, NULL );
}
MultilanguageSupport::~MultilanguageSupport()
// Pointers to the text buffer.
const Character* const textBuffer = text.Begin();
+ // Initialize whether is right to left direction
+ currentScriptRun.isRightToLeft = false;
+
// Traverse all characters and set the scripts.
const Length lastCharacter = startIndex + numberOfCharacters;
for( Length index = startIndex; index < lastCharacter; ++index )
while( !endOfText &&
( TextAbstraction::COMMON == script ) )
{
+ // Check if whether is right to left markup and Keeps true if the previous value was true.
+ currentScriptRun.isRightToLeft = currentScriptRun.isRightToLeft || TextAbstraction::IsRightToLeftMark( character );
+
if( TextAbstraction::EMOJI == currentScriptRun.script )
{
// Emojis doesn't mix well with characters common to all scripts. Insert the emoji run.
currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
// Store the script run.
- if( TextAbstraction::UNKNOWN == currentScriptRun.script )
- {
- currentScriptRun.script = TextAbstraction::LATIN;
- }
scripts.Insert( scripts.Begin() + scriptIndex, currentScriptRun );
++scriptIndex;
currentScriptRun.characterRun.numberOfCharacters = 0u;
currentScriptRun.script = TextAbstraction::UNKNOWN;
numberOfAllScriptCharacters = 0u;
+ // Initialize whether is right to left direction
+ currentScriptRun.isRightToLeft = false;
}
// Get the next character.
( TextAbstraction::EMOJI != script ) )
{
// Sets the direction of the first valid script.
- isParagraphRTL = TextAbstraction::IsRightToLeftScript( script );
+ isParagraphRTL = currentScriptRun.isRightToLeft || TextAbstraction::IsRightToLeftScript( script );
isFirstScriptToBeSet = false;
}
else if( ( TextAbstraction::UNKNOWN == currentScriptRun.script ) &&
( TextAbstraction::EMOJI == script ) )
{
- currentScriptRun.script = TextAbstraction::LATIN;
currentScriptRun.characterRun.numberOfCharacters += numberOfAllScriptCharacters;
numberOfAllScriptCharacters = 0u;
}
currentScriptRun.characterRun.numberOfCharacters = numberOfAllScriptCharacters + 1u; // Adds the white spaces which are at the begining of the script.
currentScriptRun.script = script;
numberOfAllScriptCharacters = 0u;
+ // Check if whether is right to left script.
+ currentScriptRun.isRightToLeft = TextAbstraction::IsRightToLeftScript( currentScriptRun.script );
}
else
{
if( 0u != currentScriptRun.characterRun.numberOfCharacters )
{
- if( TextAbstraction::UNKNOWN == currentScriptRun.script )
- {
- // There are only white spaces in the last script. Set the latin script.
- currentScriptRun.script = TextAbstraction::LATIN;
- }
-
// Store the last run.
scripts.Insert( scripts.Begin() + scriptIndex, currentScriptRun );
++scriptIndex;
void MultilanguageSupport::ValidateFonts( const Vector<Character>& text,
const Vector<ScriptRun>& scripts,
const Vector<FontDescriptionRun>& fontDescriptions,
- FontId defaultFontId,
+ const TextAbstraction::FontDescription& defaultFontDescription,
+ TextAbstraction::PointSize26Dot6 defaultFontPointSize,
CharacterIndex startIndex,
Length numberOfCharacters,
Vector<FontRun>& fonts )
currentFontRun.characterRun.characterIndex = startIndex;
currentFontRun.characterRun.numberOfCharacters = 0u;
currentFontRun.fontId = 0u;
+ currentFontRun.isBoldRequired = false;
+ currentFontRun.isItalicRequired = false;
// Get the font client.
TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
- // Get the default font description and default size.
- TextAbstraction::FontDescription defaultFontDescription;
- TextAbstraction::PointSize26Dot6 defaultPointSize = TextAbstraction::FontClient::DEFAULT_POINT_SIZE;
- if( defaultFontId > 0u )
- {
- fontClient.GetDescription( defaultFontId, defaultFontDescription );
- defaultPointSize = fontClient.GetPointSize( defaultFontId );
- }
-
- // Merge font descriptions
- Vector<FontId> fontIds;
- fontIds.Resize( numberOfCharacters, defaultFontId );
- Vector<bool> isDefaultFont;
- isDefaultFont.Resize( numberOfCharacters, true );
- MergeFontDescriptions( fontDescriptions,
- fontIds,
- isDefaultFont,
- defaultFontDescription,
- defaultPointSize,
- startIndex,
- numberOfCharacters );
-
const Character* const textBuffer = text.Begin();
- const FontId* const fontIdsBuffer = fontIds.Begin();
- const bool* const isDefaultFontBuffer = isDefaultFont.Begin();
+
+ // Iterators of the script runs.
Vector<ScriptRun>::ConstIterator scriptRunIt = scripts.Begin();
Vector<ScriptRun>::ConstIterator scriptRunEndIt = scripts.End();
bool isNewParagraphCharacter = false;
- PointSize26Dot6 currentPointSize = defaultPointSize;
- FontId currentFontId = 0u;
- FontId previousFontId = 0u;
bool isPreviousEmojiScript = false;
- // Whether it's the first set of characters to be validated.
- // Used in case the paragraph starts with characters common to all scripts.
- bool isFirstSetToBeValidated = true;
-
CharacterIndex lastCharacter = startIndex + numberOfCharacters;
for( Length index = startIndex; index < lastCharacter; ++index )
{
// Get the current character.
const Character character = *( textBuffer + index );
+ bool isItalicRequired = false;
+ bool isBoldRequired = false;
+
+ // new description for current character
+ TextAbstraction::FontDescription currentFontDescription;
+ TextAbstraction::PointSize26Dot6 currentFontPointSize = defaultFontPointSize;
+ bool isDefaultFont = true;
+ MergeFontDescriptions( fontDescriptions,
+ defaultFontDescription,
+ defaultFontPointSize,
+ index,
+ currentFontDescription,
+ currentFontPointSize,
+ isDefaultFont );
// Get the font for the current character.
- FontId fontId = *( fontIdsBuffer + index - startIndex );
-
- // Whether the font being validated for the current character is a default one not set by the user.
- const bool isDefault = *( isDefaultFontBuffer + index - startIndex );
+ FontId fontId = fontClient.GetFontId( currentFontDescription, currentFontPointSize );
// Get the script for the current character.
- const Script script = GetScript( index,
- scriptRunIt,
- scriptRunEndIt );
-
- // Get the current point size.
- if( currentFontId != fontId )
- {
- currentPointSize = fontClient.GetPointSize( fontId );
- currentFontId = fontId;
- }
+ Script script = GetScript( index,
+ scriptRunIt,
+ scriptRunEndIt );
#ifdef DEBUG_ENABLED
{
// Check first in the cache of default fonts per script and size.
- DefaultFonts* defaultFonts = *( defaultFontPerScriptCacheBuffer + script );
FontId cachedDefaultFontId = 0u;
+ DefaultFonts* defaultFonts = *( defaultFontPerScriptCacheBuffer + script );
if( NULL != defaultFonts )
{
- cachedDefaultFontId = defaultFonts->FindFont( fontClient, currentPointSize );
+ // This cache stores fall-back fonts.
+ cachedDefaultFontId = defaultFonts->FindFont( fontClient,
+ currentFontDescription,
+ currentFontPointSize );
}
// Whether the cached default font is valid.
// The font is valid if it matches with the default one for the current script and size and it's different than zero.
isValidFont = isValidCachedDefaultFont && ( fontId == cachedDefaultFontId );
+ if( isValidFont )
+ {
+ // Check if the font supports the character.
+ isValidFont = fontClient.IsCharacterSupportedByFont( fontId, character );
+ }
+
bool isCommonScript = false;
bool isEmojiScript = TextAbstraction::EMOJI == script;
currentFontRun.characterRun.characterIndex = currentFontRun.characterRun.characterIndex + currentFontRun.characterRun.numberOfCharacters;
currentFontRun.characterRun.numberOfCharacters = 0u;
currentFontRun.fontId = fontId;
+ currentFontRun.isItalicRequired = false;
+ currentFontRun.isBoldRequired = false;
}
-
// If the given font is not valid, it means either:
// - there is no cached font for the current script yet or,
// - the user has set a different font than the default one for the current script or,
// supports the 'white space'. However, that font may not support the DEVANAGARI script.
isCommonScript = TextAbstraction::IsCommonScript( character );
- if( isCommonScript )
+ // Check in the valid fonts cache.
+ ValidateFontsPerScript* validateFontsPerScript = *( validFontsPerScriptCacheBuffer + script );
+
+ if( NULL != validateFontsPerScript )
{
- if( isValidCachedDefaultFont &&
- ( isDefault || ( currentFontId == previousFontId ) ) &&
- !isEmojiScript )
+ // This cache stores valid fonts set by the user.
+ isValidFont = validateFontsPerScript->IsValidFont( fontId );
+
+ // It may happen that a validated font for a script doesn't have all the glyphs for that script.
+ // i.e a font validated for the CJK script may contain glyphs for the chinese language but not for the Japanese.
+ if( isValidFont )
{
- // At this point the character common for all scripts has no font assigned.
- // If there is a valid previously cached default font for it, use that one.
- fontId = cachedDefaultFontId;
- isValidFont = true;
+ // Checks if the current character is supported by the font is needed.
+ isValidFont = fontClient.IsCharacterSupportedByFont( fontId, character );
}
}
- else
+
+ if( !isValidFont ) // (2)
{
- // Check in the valid fonts cache.
- ValidateFontsPerScript* validateFontsPerScript = *( validFontsPerScriptCacheBuffer + script );
+ // The selected font is not stored in any cache.
- if( NULL != validateFontsPerScript )
- {
- isValidFont = validateFontsPerScript->IsValidFont( fontId );
- }
+ // Checks if the current character is supported by the selected font.
+ isValidFont = fontClient.IsCharacterSupportedByFont( fontId, character );
- if( !isValidFont ) // (2)
+ // If there is a valid font, cache it.
+ if( isValidFont && !isCommonScript )
{
- // Use the font client to validate the font.
- const GlyphIndex glyphIndex = fontClient.GetGlyphIndex( fontId, character );
-
- // The font is valid if there is a glyph for that character.
- isValidFont = 0u != glyphIndex;
-
- // Emojis are present in many monochrome fonts; prefer color by default.
- if( isValidFont &&
- isEmojiScript )
+ if( NULL == validateFontsPerScript )
{
- const PixelData bitmap = fontClient.CreateBitmap( fontId, glyphIndex );
+ validateFontsPerScript = new ValidateFontsPerScript();
- // For color emojis, the font is valid if the bitmap is RGBA.
- isValidFont = bitmap && ( Pixel::BGRA8888 == bitmap.GetPixelFormat() );
+ *( validFontsPerScriptCacheBuffer + script ) = validateFontsPerScript;
}
- // If there is a valid font, cache it.
- if( isValidFont )
- {
- if( NULL == validateFontsPerScript )
- {
- validateFontsPerScript = new ValidateFontsPerScript();
+ validateFontsPerScript->mValidFonts.PushBack( fontId );
+ }
- *( validFontsPerScriptCacheBuffer + script ) = validateFontsPerScript;
- }
+ if( !isValidFont && ( fontId != cachedDefaultFontId ) && ( !TextAbstraction::IsNewParagraph( character ) )) // (3)
+ {
+ // The selected font by the user or the platform's default font has failed to validate the character.
- validateFontsPerScript->mValidFonts.PushBack( fontId );
+ // Checks if the previously discarted cached default font supports the character.
+ bool isValidCachedFont = false;
+ if( isValidCachedDefaultFont )
+ {
+ isValidCachedFont = fontClient.IsCharacterSupportedByFont( cachedDefaultFontId, character );
}
- if( !isValidFont ) // (3)
+ if( isValidCachedFont )
{
- // The given font has not been validated.
-
- if( isValidCachedDefaultFont )
- {
- // Use the cached default font for the script if there is one.
- fontId = cachedDefaultFontId;
- }
- else
- {
- // There is no valid cached default font for the script.
-
- DefaultFonts* defaultFontsPerScript = NULL;
-
- // Emojis are present in many monochrome fonts; prefer color by default.
- const bool preferColor = ( TextAbstraction::EMOJI == script );
+ // Use the cached default font for the script if there is one.
+ fontId = cachedDefaultFontId;
+ }
+ else
+ {
+ // There is no valid cached default font for the script.
- // Find a fallback-font.
- fontId = fontClient.FindFallbackFont( currentFontId, character, currentPointSize, preferColor );
+ DefaultFonts* defaultFontsPerScript = NULL;
- if( 0u == fontId )
- {
- // If the system does not support a suitable font, fallback to Latin
- defaultFontsPerScript = *( defaultFontPerScriptCacheBuffer + TextAbstraction::LATIN );
- if( NULL != defaultFontsPerScript )
- {
- fontId = defaultFontsPerScript->FindFont( fontClient, currentPointSize );
- }
- }
+ // Find a fallback-font.
+ fontId = fontClient.FindFallbackFont( character,
+ currentFontDescription,
+ currentFontPointSize,
+ false );
- if( 0u == fontId )
- {
- fontId = fontClient.FindDefaultFont( UTF32_A, currentPointSize );
- }
+ if( 0u == fontId )
+ {
+ fontId = fontClient.FindDefaultFont( UTF32_A, currentFontPointSize );
+ }
- // Cache the font.
+ if ( !isCommonScript && (script != TextAbstraction::UNKNOWN) )
+ {
+ // Cache the font if it is not an unknown script
if( NULL == defaultFontsPerScript )
{
defaultFontsPerScript = *( defaultFontPerScriptCacheBuffer + script );
*( defaultFontPerScriptCacheBuffer + script ) = defaultFontsPerScript;
}
}
- defaultFontsPerScript->mFonts.PushBack( fontId );
+ defaultFontsPerScript->Cache( currentFontDescription, fontId );
}
- } // !isValidFont (3)
- } // !isValidFont (2)
- } // !isCommonScript
+ }
+ } // !isValidFont (3)
+ } // !isValidFont (2)
} // !isValidFont (1)
#ifdef DEBUG_ENABLED
}
#endif
- if( isFirstSetToBeValidated && !isCommonScript )
- {
- currentFontRun.fontId = fontId;
- isFirstSetToBeValidated = false;
- }
+ // Whether bols style is required.
+ isBoldRequired = ( currentFontDescription.weight >= TextAbstraction::FontWeight::BOLD );
+
+ // Whether italic style is required.
+ isItalicRequired = ( currentFontDescription.slant >= TextAbstraction::FontSlant::ITALIC );
// The font is now validated.
if( ( fontId != currentFontRun.fontId ) ||
- isNewParagraphCharacter )
+ isNewParagraphCharacter ||
+ // If font id is same as previous but style is diffrent, initialize new one
+ ( ( fontId == currentFontRun.fontId ) && ( ( isBoldRequired != currentFontRun.isBoldRequired ) || ( isItalicRequired != currentFontRun.isItalicRequired ) ) ) )
{
// Current run needs to be stored and a new one initialized.
currentFontRun.characterRun.characterIndex = currentFontRun.characterRun.characterIndex + currentFontRun.characterRun.numberOfCharacters;
currentFontRun.characterRun.numberOfCharacters = 0u;
currentFontRun.fontId = fontId;
-
- if( isNewParagraphCharacter )
- {
- isFirstSetToBeValidated = true;
- }
+ currentFontRun.isBoldRequired = isBoldRequired;
+ currentFontRun.isItalicRequired = isItalicRequired;
}
// Add one more character to the run.
// Whether the current character is a new paragraph character.
isNewParagraphCharacter = TextAbstraction::IsNewParagraph( character );
- previousFontId = currentFontId;
isPreviousEmojiScript = isEmojiScript;
} // end traverse characters.