/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
#include <dali-toolkit/internal/text/layouts/layout-engine.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/math/vector2.h>
-#include <dali/public-api/text-abstraction/font-client.h>
+#include <limits>
+#include <dali/integration-api/debug.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/text/layouts/layout-parameters.h>
#include <dali-toolkit/internal/text/bidirectional-line-info-run.h>
+#include <dali-toolkit/internal/text/cursor-helper-functions.h>
+#include <dali-toolkit/internal/text/glyph-metrics-helper.h>
+#include <dali-toolkit/internal/text/layouts/layout-parameters.h>
namespace Dali
{
namespace Text
{
+namespace Layout
+{
+
+namespace
+{
+
+#if defined(DEBUG_ENABLED)
+ Debug::Filter* gLogFilter = Debug::Filter::New(Debug::Concise, true, "LOG_TEXT_LAYOUT");
+#endif
+
+const float MAX_FLOAT = std::numeric_limits<float>::max();
+const bool RTL = true;
+const float CURSOR_WIDTH = 1.f;
+const float LINE_SPACING= 0.f;
+
+} //namespace
+
/**
* @brief Stores temporary layout info of the line.
*/
struct LineLayout
{
+ LineLayout()
+ : glyphIndex( 0u ),
+ characterIndex( 0u ),
+ numberOfGlyphs( 0u ),
+ numberOfCharacters( 0u ),
+ length( 0.f ),
+ extraBearing( 0.f ),
+ extraWidth( 0.f ),
+ wsLengthEndOfLine( 0.f ),
+ ascender( 0.f ),
+ descender( MAX_FLOAT )
+ {}
+
+ ~LineLayout()
+ {}
+
+ void Clear()
+ {
+ glyphIndex = 0u;
+ characterIndex = 0u;
+ numberOfGlyphs = 0u;
+ numberOfCharacters = 0u;
+ length = 0.f;
+ extraBearing = 0.f;
+ extraWidth = 0.f;
+ wsLengthEndOfLine = 0.f;
+ ascender = 0.f;
+ descender = MAX_FLOAT;
+ }
+
GlyphIndex glyphIndex; ///< Index of the first glyph to be laid-out.
CharacterIndex characterIndex; ///< Index of the first character to be laid-out.
- Length numberOfCharacters; ///< The number of characters which fit in one line.
Length numberOfGlyphs; ///< The number of glyph which fit in one line.
- float length; ///< The length of the glyphs which fit in one line.
+ Length numberOfCharacters; ///< The number of characters which fit in one line.
+ float length; ///< The addition of the advance metric of all the glyphs which fit in one line.
+ float extraBearing; ///< The extra width to be added to the line's length when the bearing of the first glyph is negative.
+ float extraWidth; ///< The extra width to be added to the line's length when the bearing + width of the last glyph is greater than the advance.
float wsLengthEndOfLine; ///< The length of the white spaces at the end of the line.
- float height; ///< The maximum height of all fonts in the line.
float ascender; ///< The maximum ascender of all fonts in the line.
+ float descender; ///< The minimum descender of all fonts in the line.
};
-struct LayoutEngine::Impl
+struct Engine::Impl
{
Impl()
- : mLayout( LayoutEngine::SINGLE_LINE_BOX ),
- mAlignment( LayoutEngine::ALIGN_BEGIN )
+ : mLayout( Layout::Engine::SINGLE_LINE_BOX ),
+ mCursorWidth( CURSOR_WIDTH ),
+ mDefaultLineSpacing( LINE_SPACING )
{
- mFontClient = TextAbstraction::FontClient::Get();
}
/**
- * Retrieves the line layout for a given box width.
+ * @brief Updates the line ascender and descender with the metrics of a new font.
+ *
+ * @param[in] fontId The id of the new font.
+ * @param[in,out] lineLayout The line layout.
*/
- void GetLineLayoutForBox( const LayoutParameters& parameters,
- LineLayout& lineLayout )
+ void UpdateLineHeight( FontId fontId, LineLayout& lineLayout )
{
- // Initializes the line layout.
- lineLayout.numberOfCharacters = 0u;
- lineLayout.numberOfGlyphs = 0u;
- lineLayout.length = 0.f;
- lineLayout.wsLengthEndOfLine = 0.f;
- lineLayout.height = 0.f;
- lineLayout.ascender = 0.f;
-
- // Get the last glyph index.
- const GlyphIndex lastGlyphIndex = parameters.totalNumberOfGlyphs - 1u;
-
- FontId lastFontId = 0u;
- for( GlyphIndex glyphIndex = lineLayout.glyphIndex;
- glyphIndex < parameters.totalNumberOfGlyphs;
- ++glyphIndex )
- {
- // Get the glyph info.
- const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + glyphIndex );
+ Text::FontMetrics fontMetrics;
+ mMetrics->GetFontMetrics( fontId, fontMetrics );
- // Check whether is a white space.
- const Character character = *( parameters.textBuffer + lineLayout.numberOfCharacters );
- const bool isWhiteSpace = TextAbstraction::IsWhiteSpace( character );
-
- // Get the character indices for the current glyph. The last character index is needed
- // because there are glyphs formed by more than one character but their break info is
- // given only for the last character.
- const Length charactersPerGlyph = *( parameters.charactersPerGlyphBuffer + glyphIndex );
-
- // Increase the number of characters.
- lineLayout.numberOfCharacters += charactersPerGlyph;
-
- // Increase the number of glyphs.
- lineLayout.numberOfGlyphs++;
-
- // Increase the accumulated length.
- const float glyphLength = ( glyphIndex == lastGlyphIndex ) ? glyphInfo.width : glyphInfo.advance;
+ // Sets the maximum ascender.
+ if( fontMetrics.ascender > lineLayout.ascender )
+ {
+ lineLayout.ascender = fontMetrics.ascender;
+ }
- if( isWhiteSpace )
- {
- // Add the length to the length of white spaces at the end of the line.
- lineLayout.wsLengthEndOfLine += glyphLength;
- }
- else
- {
- // Add as well any previous white space length.
- lineLayout.length += lineLayout.wsLengthEndOfLine + glyphLength;
+ // Sets the minimum descender.
+ if( fontMetrics.descender < lineLayout.descender )
+ {
+ lineLayout.descender = fontMetrics.descender;
+ }
+ }
- // Clear the white space length at the end of the line.
- lineLayout.wsLengthEndOfLine = 0.f;
- }
+ /**
+ * @brief Merges a temporary line layout into the line layout.
+ *
+ * @param[in,out] lineLayout The line layout.
+ * @param[in] tmpLineLayout A temporary line layout.
+ */
+ void MergeLineLayout( LineLayout& lineLayout,
+ const LineLayout& tmpLineLayout )
+ {
+ lineLayout.numberOfCharacters += tmpLineLayout.numberOfCharacters;
+ lineLayout.numberOfGlyphs += tmpLineLayout.numberOfGlyphs;
+ lineLayout.length += tmpLineLayout.length;
- if( lastFontId != glyphInfo.fontId )
- {
- Text::FontMetrics fontMetrics;
- mFontClient.GetFontMetrics( glyphInfo.fontId, fontMetrics );
+ if( 0.f < tmpLineLayout.length )
+ {
+ lineLayout.length += lineLayout.wsLengthEndOfLine;
- // Sets the maximum height.
- if( fontMetrics.height > lineLayout.height )
- {
- lineLayout.height = fontMetrics.height;
- }
+ lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine;
+ }
+ else
+ {
+ lineLayout.wsLengthEndOfLine += tmpLineLayout.wsLengthEndOfLine;
+ }
- // Sets the maximum ascender.
- if( fontMetrics.ascender > lineLayout.ascender )
- {
- lineLayout.ascender = fontMetrics.ascender;
- }
+ if( tmpLineLayout.ascender > lineLayout.ascender )
+ {
+ lineLayout.ascender = tmpLineLayout.ascender;
+ }
- lastFontId = glyphInfo.fontId;
- }
+ if( tmpLineLayout.descender < lineLayout.descender )
+ {
+ lineLayout.descender = tmpLineLayout.descender;
}
}
/**
* Retrieves the line layout for a given box width.
+ *
+ * @note This method lais out text as it were left to right. At this point is not possible to reorder the line
+ * because the number of characters of the line is not known (one of the responsabilities of this method
+ * is calculate that). Due to glyph's 'x' bearing, width and advance, when right to left or mixed right to left
+ * and left to right text is laid-out, it can be small differences in the line length. One solution is to
+ * reorder and re-lay out the text after this method and add or remove one extra glyph if needed. However,
+ * this method calculates which are the first and last glyphs of the line (the ones that causes the
+ * differences). This is a good point to check if there is problems with the text exceeding the boundaries
+ * of the control when there is right to left text.
+ *
+ * @param[in] parameters The layout parameters.
+ * @param[out] lineLayout The line layout.
+ * @param[in,out] paragraphDirection in: the current paragraph's direction, out: the next paragraph's direction. Is set after a must break.
+ * @param[in] completelyFill Whether to completely fill the line ( even if the last word exceeds the boundaries ).
*/
- void GetMultiLineLayoutForBox( const LayoutParameters& parameters,
- LineLayout& lineLayout )
+ void GetLineLayoutForBox( const Parameters& parameters,
+ LineLayout& lineLayout,
+ CharacterDirection& paragraphDirection,
+ bool completelyFill )
{
- // Initializes the line layout.
- lineLayout.numberOfCharacters = 0u;
- lineLayout.numberOfGlyphs = 0u;
- lineLayout.length = 0.f;
- lineLayout.wsLengthEndOfLine = 0.f;
- lineLayout.height = 0.f;
- lineLayout.ascender = 0.f;
-
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->GetLineLayoutForBox\n" );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " initial glyph index : %d\n", lineLayout.glyphIndex );
// Stores temporary line layout which has not been added to the final line layout.
LineLayout tmpLineLayout;
- tmpLineLayout.numberOfCharacters = 0u;
- tmpLineLayout.numberOfGlyphs = 0u;
- tmpLineLayout.length = 0.f;
- tmpLineLayout.wsLengthEndOfLine = 0.f;
- tmpLineLayout.height = 0.f;
- tmpLineLayout.ascender = 0.f;
- // Get the last glyph index.
- const GlyphIndex lastGlyphIndex = parameters.totalNumberOfGlyphs - 1u;
+ const bool isMultiline = mLayout == MULTI_LINE_BOX;
+ const bool isWordLaidOut = parameters.lineWrapMode == Text::LineWrap::WORD;
+
+ // The last glyph to be laid-out.
+ const GlyphIndex lastGlyphOfParagraphPlusOne = parameters.startGlyphIndex + parameters.numberOfGlyphs;
+
+ // If the first glyph has a negative bearing its absolute value needs to be added to the line length.
+ // In the case the line starts with a right to left character, if the width is longer than the advance,
+ // the difference needs to be added to the line length.
+
+ // Check whether the first glyph comes from a character that is shaped in multiple glyphs.
+ const Length numberOfGLyphsInGroup = GetNumberOfGlyphsOfGroup( lineLayout.glyphIndex,
+ lastGlyphOfParagraphPlusOne,
+ parameters.charactersPerGlyphBuffer );
+
+ GlyphMetrics glyphMetrics;
+ GetGlyphsMetrics( lineLayout.glyphIndex,
+ numberOfGLyphsInGroup,
+ glyphMetrics,
+ parameters.glyphsBuffer,
+ mMetrics );
+
+ // Set the direction of the first character of the line.
+ lineLayout.characterIndex = *( parameters.glyphsToCharactersBuffer + lineLayout.glyphIndex );
+ const CharacterDirection firstCharacterDirection = ( NULL == parameters.characterDirectionBuffer ) ? false : *( parameters.characterDirectionBuffer + lineLayout.characterIndex );
+ CharacterDirection previousCharacterDirection = firstCharacterDirection;
+
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
+ float tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
+
+ float tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
+
+ tmpLineLayout.length += mCursorWidth; // Added to give some space to the cursor.
+
+ // Calculate the line height if there is no characters.
+ FontId lastFontId = glyphMetrics.fontId;
+ UpdateLineHeight( lastFontId, tmpLineLayout );
+
+ bool oneWordLaidOut = false;
- FontId lastFontId = 0u;
for( GlyphIndex glyphIndex = lineLayout.glyphIndex;
- glyphIndex < parameters.totalNumberOfGlyphs;
- ++glyphIndex )
+ glyphIndex < lastGlyphOfParagraphPlusOne; )
{
- // Get the glyph info.
- const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + glyphIndex );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index : %d\n", glyphIndex );
+
+ // Check whether this glyph comes from a character that is shaped in multiple glyphs.
+ const Length numberOfGLyphsInGroup = GetNumberOfGlyphsOfGroup( glyphIndex,
+ lastGlyphOfParagraphPlusOne,
+ parameters.charactersPerGlyphBuffer );
+
+ GlyphMetrics glyphMetrics;
+ GetGlyphsMetrics( glyphIndex,
+ numberOfGLyphsInGroup,
+ glyphMetrics,
+ parameters.glyphsBuffer,
+ mMetrics );
+
+ const bool isLastGlyph = glyphIndex + numberOfGLyphsInGroup == parameters.totalNumberOfGlyphs;
+
+ // Check if the font of the current glyph is the same of the previous one.
+ // If it's different the ascender and descender need to be updated.
+ if( lastFontId != glyphMetrics.fontId )
+ {
+ UpdateLineHeight( glyphMetrics.fontId, tmpLineLayout );
+ lastFontId = glyphMetrics.fontId;
+ }
// Get the character indices for the current glyph. The last character index is needed
// because there are glyphs formed by more than one character but their break info is
// given only for the last character.
- const Length charactersPerGlyph = *( parameters.charactersPerGlyphBuffer + glyphIndex );
+ const Length charactersPerGlyph = *( parameters.charactersPerGlyphBuffer + glyphIndex + numberOfGLyphsInGroup - 1u );
+ const bool hasCharacters = charactersPerGlyph > 0u;
const CharacterIndex characterFirstIndex = *( parameters.glyphsToCharactersBuffer + glyphIndex );
- const CharacterIndex characterLastIndex = characterFirstIndex + ( ( 1u > charactersPerGlyph ) ? 0u : charactersPerGlyph - 1u );
+ const CharacterIndex characterLastIndex = characterFirstIndex + ( hasCharacters ? charactersPerGlyph - 1u : 0u );
// Get the line break info for the current character.
- const LineBreakInfo lineBreakInfo = *( parameters.lineBreakInfoBuffer + characterLastIndex );
+ const LineBreakInfo lineBreakInfo = hasCharacters ? *( parameters.lineBreakInfoBuffer + characterLastIndex ) : TextAbstraction::LINE_NO_BREAK;
// Get the word break info for the current character.
const WordBreakInfo wordBreakInfo = *( parameters.wordBreakInfoBuffer + characterLastIndex );
tmpLineLayout.numberOfCharacters += charactersPerGlyph;
// Increase the number of glyphs.
- tmpLineLayout.numberOfGlyphs++;
+ tmpLineLayout.numberOfGlyphs += numberOfGLyphsInGroup;
// Check whether is a white space.
const Character character = *( parameters.textBuffer + characterFirstIndex );
const bool isWhiteSpace = TextAbstraction::IsWhiteSpace( character );
+ // Used to restore the temporal line layout when a single word does not fit in the control's width and is split by character.
+ const float previousTmpLineLength = tmpLineLayout.length;
+ const float previousTmpExtraBearing = tmpExtraBearing;
+ const float previousTmpExtraWidth = tmpExtraWidth;
+
+ // Get the character's direction.
+ const CharacterDirection characterDirection = ( NULL == parameters.characterDirectionBuffer ) ? false : *( parameters.characterDirectionBuffer + characterFirstIndex );
+
// Increase the accumulated length.
if( isWhiteSpace )
{
// Add the length to the length of white spaces at the end of the line.
- tmpLineLayout.wsLengthEndOfLine += glyphInfo.advance; // I use the advance as the width is always zero for the white spaces.
+ tmpLineLayout.wsLengthEndOfLine += glyphMetrics.advance; // The advance is used as the width is always zero for the white spaces.
}
else
{
// Add as well any previous white space length.
- tmpLineLayout.length += tmpLineLayout.wsLengthEndOfLine + ( glyphIndex == lastGlyphIndex ) ? glyphInfo.width : glyphInfo.advance;
+ tmpLineLayout.length += tmpLineLayout.wsLengthEndOfLine + glyphMetrics.advance;
+
+ // An extra space may be added to the line for the first and last glyph of the line.
+ // If the bearing of the first glyph is negative, its positive value needs to be added.
+ // If the bearing plus the width of the last glyph is greater than the advance, the difference
+ // needs to be added.
+
+ if( characterDirection == paragraphDirection )
+ {
+ if( RTL == characterDirection )
+ {
+ // <--
+ // | Rrrrr|
+ // or
+ // | Rllrrr|
+ // or
+ // |lllrrrrr|
+ // | Rll|
+ //
+
+ tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
+ }
+ else // LTR
+ {
+ // -->
+ // |lllL |
+ // or
+ // |llrrL |
+ // or
+ // |lllllrrr|
+ // |rrL |
+ //
+
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
+ tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
+ }
+ }
+ else
+ {
+ if( characterDirection != previousCharacterDirection )
+ {
+ if( RTL == characterDirection )
+ {
+ // -->
+ // |lllR |
+
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
+ tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
+ }
+ else // LTR
+ {
+ // <--
+ // | Lrrrr|
+
+ tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
+ }
+ }
+ else if( characterDirection == firstCharacterDirection )
+ {
+ if( RTL == characterDirection )
+ {
+ // -->
+ // |llllllrr|
+ // |Rr |
+
+ tmpExtraBearing = ( 0.f > glyphMetrics.xBearing ) ? -glyphMetrics.xBearing : 0.f;
+ }
+ else // LTR
+ {
+ // <--
+ // |llllrrrr|
+ // | llL|
+
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
+ tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
+ }
+ }
+ }
// Clear the white space length at the end of the line.
tmpLineLayout.wsLengthEndOfLine = 0.f;
}
// Check if the accumulated length fits in the width of the box.
- if( lineLayout.length + tmpLineLayout.length + ( ( 0.f < tmpLineLayout.length ) ? lineLayout.wsLengthEndOfLine : 0.f ) > parameters.boundingBox.width )
+ if( ( completelyFill || isMultiline ) && !isWhiteSpace &&
+ ( tmpExtraBearing + lineLayout.length + lineLayout.wsLengthEndOfLine + tmpLineLayout.length + tmpExtraWidth > parameters.boundingBox.width ) )
{
// Current word does not fit in the box's width.
+ if( !oneWordLaidOut || completelyFill )
+ {
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Break the word by character\n" );
+
+ // The word doesn't fit in the control's width. It needs to be split by character.
+ if( tmpLineLayout.numberOfGlyphs > 0u )
+ {
+ tmpLineLayout.numberOfCharacters -= charactersPerGlyph;
+ tmpLineLayout.numberOfGlyphs -= numberOfGLyphsInGroup;
+ tmpLineLayout.length = previousTmpLineLength;
+ tmpExtraBearing = previousTmpExtraBearing;
+ tmpExtraWidth = previousTmpExtraWidth;
+ }
+
+ // Add part of the word to the line layout.
+ MergeLineLayout( lineLayout, tmpLineLayout );
+ }
+ else
+ {
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Current word does not fit.\n" );
+ }
+
+ lineLayout.extraBearing = tmpExtraBearing;
+ lineLayout.extraWidth = tmpExtraWidth;
+
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox.\n" );
+
return;
}
- if( TextAbstraction::LINE_MUST_BREAK == lineBreakInfo )
+ if( ( isMultiline || isLastGlyph ) &&
+ ( TextAbstraction::LINE_MUST_BREAK == lineBreakInfo ) )
{
// Must break the line. Update the line layout and return.
- lineLayout.numberOfCharacters += tmpLineLayout.numberOfCharacters;
- lineLayout.numberOfGlyphs += tmpLineLayout.numberOfGlyphs;
- lineLayout.length += tmpLineLayout.length;
+ MergeLineLayout( lineLayout, tmpLineLayout );
- if( 0.f < tmpLineLayout.length )
+ // Set the next paragraph's direction.
+ if( !isLastGlyph &&
+ ( NULL != parameters.characterDirectionBuffer ) )
{
- lineLayout.length += lineLayout.wsLengthEndOfLine;
-
- lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine;
- }
- else
- {
- lineLayout.wsLengthEndOfLine += tmpLineLayout.wsLengthEndOfLine;
+ paragraphDirection = *( parameters.characterDirectionBuffer + 1u + characterLastIndex );
}
- if( tmpLineLayout.height > lineLayout.height )
- {
- lineLayout.height = tmpLineLayout.height;
- }
+ lineLayout.extraBearing = tmpExtraBearing;
+ lineLayout.extraWidth = tmpExtraWidth;
- if( tmpLineLayout.ascender > lineLayout.ascender )
- {
- lineLayout.ascender = tmpLineLayout.ascender;
- }
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Must break\n" );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" );
- tmpLineLayout.numberOfCharacters = 0u;
- tmpLineLayout.numberOfGlyphs = 0u;
- tmpLineLayout.length = 0u;
- tmpLineLayout.wsLengthEndOfLine = 0u;
- tmpLineLayout.height = 0.f;
- tmpLineLayout.ascender = 0.f;
return;
}
- if( TextAbstraction::WORD_BREAK == wordBreakInfo )
+ if( isMultiline &&
+ ( TextAbstraction::WORD_BREAK == wordBreakInfo ) )
{
+ oneWordLaidOut = isWordLaidOut;
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " One word laid-out\n" );
+
// Current glyph is the last one of the current word.
// Add the temporal layout to the current one.
- lineLayout.numberOfCharacters += tmpLineLayout.numberOfCharacters;
- lineLayout.numberOfGlyphs += tmpLineLayout.numberOfGlyphs;
- lineLayout.length += tmpLineLayout.length;
- if( 0.f < tmpLineLayout.length )
- {
- lineLayout.length += lineLayout.wsLengthEndOfLine;
+ MergeLineLayout( lineLayout, tmpLineLayout );
- lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine;
- }
- else
- {
- lineLayout.wsLengthEndOfLine += tmpLineLayout.wsLengthEndOfLine;
- }
+ tmpLineLayout.Clear();
+ }
- if( tmpLineLayout.height > lineLayout.height )
- {
- lineLayout.height = tmpLineLayout.height;
- }
+ previousCharacterDirection = characterDirection;
+ glyphIndex += numberOfGLyphsInGroup;
+ }
- if( tmpLineLayout.ascender > lineLayout.ascender )
- {
- lineLayout.ascender = tmpLineLayout.ascender;
- }
+ lineLayout.extraBearing = tmpExtraBearing;
+ lineLayout.extraWidth = tmpExtraWidth;
- tmpLineLayout.numberOfCharacters = 0u;
- tmpLineLayout.numberOfGlyphs = 0u;
- tmpLineLayout.length = 0u;
- tmpLineLayout.wsLengthEndOfLine = 0u;
- tmpLineLayout.height = 0.f;
- tmpLineLayout.ascender = 0.f;
- }
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" );
+ }
- if( lastFontId != glyphInfo.fontId )
- {
- Text::FontMetrics fontMetrics;
- mFontClient.GetFontMetrics( glyphInfo.fontId, fontMetrics );
+ void SetGlyphPositions( const GlyphInfo* const glyphsBuffer,
+ Length numberOfGlyphs,
+ float outlineWidth,
+ Vector2* glyphPositionsBuffer )
+ {
+ // Traverse the glyphs and set the positions.
- // Sets the maximum height.
- if( fontMetrics.height > tmpLineLayout.height )
- {
- tmpLineLayout.height = fontMetrics.height;
- }
+ // Check if the x bearing of the first character is negative.
+ // If it has a negative x bearing, it will exceed the boundaries of the actor,
+ // so the penX position needs to be moved to the right.
- // Sets the maximum ascender.
- if( fontMetrics.ascender > tmpLineLayout.ascender )
- {
- tmpLineLayout.ascender = fontMetrics.ascender;
- }
+ const GlyphInfo& glyph = *glyphsBuffer;
+ float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing + outlineWidth : outlineWidth;
- lastFontId = glyphInfo.fontId;
- }
+
+ for( GlyphIndex i = 0u; i < numberOfGlyphs; ++i )
+ {
+ const GlyphInfo& glyph = *( glyphsBuffer + i );
+ Vector2& position = *( glyphPositionsBuffer + i );
+
+ position.x = penX + glyph.xBearing;
+ position.y = -glyph.yBearing;
+
+ penX += glyph.advance;
}
}
- bool LayoutText( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
- Size& actualSize )
+ /**
+ * @brief Resizes the line buffer.
+ *
+ * @param[in,out] lines The vector of lines. Used when the layout is created from scratch.
+ * @param[in,out] newLines The vector of lines used instead of @p lines when the layout is updated.
+ * @param[in,out] linesCapacity The capacity of the vector (either lines or newLines).
+ * @param[in] updateCurrentBuffer Whether the layout is updated.
+ *
+ * @return Pointer to either lines or newLines.
+ */
+ LineRun* ResizeLinesBuffer( Vector<LineRun>& lines,
+ Vector<LineRun>& newLines,
+ Length& linesCapacity,
+ bool updateCurrentBuffer )
+ {
+ LineRun* linesBuffer = NULL;
+ // Reserve more space for the next lines.
+ linesCapacity *= 2u;
+ if( updateCurrentBuffer )
+ {
+ newLines.Resize( linesCapacity );
+ linesBuffer = newLines.Begin();
+ }
+ else
+ {
+ lines.Resize( linesCapacity );
+ linesBuffer = lines.Begin();
+ }
+
+ return linesBuffer;
+ }
+
+ /**
+ * Ellipsis a line if it exceeds the width's of the bounding box.
+ *
+ * @param[in] layoutParameters The parameters needed to layout the text.
+ * @param[in] layout The line layout.
+ * @param[in,out] layoutSize The text's layout size.
+ * @param[in,out] linesBuffer Pointer to the line's buffer.
+ * @param[in,out] glyphPositionsBuffer Pointer to the position's buffer.
+ * @param[in,out] numberOfLines The number of laid-out lines.
+ * @param[in] penY The vertical layout position.
+ * @param[in] currentParagraphDirection The current paragraph's direction.
+ *
+ * return Whether the line is ellipsized.
+ */
+ bool EllipsisLine( const Parameters& layoutParameters,
+ const LineLayout& layout,
+ Size& layoutSize,
+ LineRun* linesBuffer,
+ Vector2* glyphPositionsBuffer,
+ Length& numberOfLines,
+ float penY,
+ CharacterDirection currentParagraphDirection )
{
- // TODO Switch between different layouts
- bool update = false;
+ const bool ellipsis = ( ( penY - layout.descender > layoutParameters.boundingBox.height ) ||
+ ( ( mLayout == SINGLE_LINE_BOX ) &&
+ ( layout.extraBearing + layout.length + layout.extraWidth > layoutParameters.boundingBox.width ) ) );
- switch( mLayout )
+ if( ellipsis )
{
- case LayoutEngine::SINGLE_LINE_BOX:
+ // Do not layout more lines if ellipsis is enabled.
+
+ // The last line needs to be completely filled with characters.
+ // Part of a word may be used.
+
+ LineRun* lineRun = NULL;
+ LineLayout ellipsisLayout;
+ if( 0u != numberOfLines )
{
- update = SingleLineLayout( layoutParameters,
- glyphPositions,
- lines,
- actualSize );
- break;
+ // Get the last line and layout it again with the 'completelyFill' flag to true.
+ lineRun = linesBuffer + ( numberOfLines - 1u );
+
+ penY -= layout.ascender - lineRun->descender;
+
+ ellipsisLayout.glyphIndex = lineRun->glyphRun.glyphIndex;
}
- case LayoutEngine::MULTI_LINE_BOX:
+ else
{
- update = MultiLineLayout( layoutParameters,
- glyphPositions,
- lines,
- actualSize );
- break;
+ // At least there is space reserved for one line.
+ lineRun = linesBuffer;
+
+ lineRun->glyphRun.glyphIndex = 0u;
+ ellipsisLayout.glyphIndex = 0u;
+
+ ++numberOfLines;
}
- default:
- break;
+
+ GetLineLayoutForBox( layoutParameters,
+ ellipsisLayout,
+ currentParagraphDirection,
+ true );
+
+ lineRun->glyphRun.numberOfGlyphs = ellipsisLayout.numberOfGlyphs;
+ lineRun->characterRun.characterIndex = ellipsisLayout.characterIndex;
+ lineRun->characterRun.numberOfCharacters = ellipsisLayout.numberOfCharacters;
+ lineRun->width = ellipsisLayout.length;
+ lineRun->extraLength = ( ellipsisLayout.wsLengthEndOfLine > 0.f ) ? ellipsisLayout.wsLengthEndOfLine - ellipsisLayout.extraWidth : 0.f;
+ lineRun->ascender = ellipsisLayout.ascender;
+ lineRun->descender = ellipsisLayout.descender;
+ lineRun->direction = !RTL;
+ lineRun->ellipsis = true;
+
+ layoutSize.width = layoutParameters.boundingBox.width;
+ if( layoutSize.height < Math::MACHINE_EPSILON_1000 )
+ {
+ layoutSize.height += ( lineRun->ascender + -lineRun->descender );
+ }
+
+ SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun->glyphRun.glyphIndex,
+ ellipsisLayout.numberOfGlyphs,
+ layoutParameters.outlineWidth,
+ glyphPositionsBuffer + lineRun->glyphRun.glyphIndex - layoutParameters.startGlyphIndex );
}
- return update;
+ return ellipsis;
}
- void ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions )
+ /**
+ * @brief Updates the text layout with a new laid-out line.
+ *
+ * @param[in] layoutParameters The parameters needed to layout the text.
+ * @param[in] layout The line layout.
+ * @param[in,out] layoutSize The text's layout size.
+ * @param[in,out] linesBuffer Pointer to the line's buffer.
+ * @param[in] index Index to the vector of glyphs.
+ * @param[in,out] numberOfLines The number of laid-out lines.
+ * @param[in] isLastLine Whether the laid-out line is the last one.
+ */
+ void UpdateTextLayout( const Parameters& layoutParameters,
+ const LineLayout& layout,
+ Size& layoutSize,
+ LineRun* linesBuffer,
+ GlyphIndex index,
+ Length& numberOfLines,
+ bool isLastLine )
{
- for( LineIndex lineIndex = 0u; lineIndex < layoutParameters.numberOfBidirectionalInfoRuns; ++lineIndex )
+ LineRun& lineRun = *( linesBuffer + numberOfLines );
+ ++numberOfLines;
+
+ lineRun.glyphRun.glyphIndex = index;
+ lineRun.glyphRun.numberOfGlyphs = layout.numberOfGlyphs;
+ lineRun.characterRun.characterIndex = layout.characterIndex;
+ lineRun.characterRun.numberOfCharacters = layout.numberOfCharacters;
+ if( isLastLine && !layoutParameters.isLastNewParagraph )
{
- const BidirectionalLineInfoRun& bidiLine = *( layoutParameters.lineBidirectionalInfoRunsBuffer +lineIndex );
-
- float penX = 0.f;
+ const float width = layout.extraBearing + layout.length + layout.extraWidth + layout.wsLengthEndOfLine;
+ if( MULTI_LINE_BOX == mLayout )
+ {
+ lineRun.width = ( width > layoutParameters.boundingBox.width ) ? layoutParameters.boundingBox.width : width;
+ }
+ else
+ {
+ lineRun.width = width;
+ }
- Vector2* glyphPositionsBuffer = glyphPositions.Begin();
+ lineRun.extraLength = 0.f;
+ }
+ else
+ {
+ lineRun.width = layout.extraBearing + layout.length + layout.extraWidth;
+ lineRun.extraLength = ( layout.wsLengthEndOfLine > 0.f ) ? layout.wsLengthEndOfLine - layout.extraWidth : 0.f;
+ }
+ lineRun.ascender = layout.ascender;
+ lineRun.descender = layout.descender;
+ lineRun.direction = !RTL;
+ lineRun.ellipsis = false;
- for( CharacterIndex characterLogicalIndex = 0u;
- characterLogicalIndex < bidiLine.characterRun.numberOfCharacters;
- ++characterLogicalIndex )
- {
- // Convert the character in the logical order into the character in the visual order.
- const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *( bidiLine.visualToLogicalMap + characterLogicalIndex );
+ // Update the actual size.
+ if( lineRun.width > layoutSize.width )
+ {
+ layoutSize.width = lineRun.width;
+ }
- // Get the number of glyphs of the character.
- const Length numberOfGlyphs = *( layoutParameters.glyphsPerCharacterBuffer + characterVisualIndex );
+ layoutSize.height += ( lineRun.ascender + -lineRun.descender );
+ }
- for( GlyphIndex index = 0u; index < numberOfGlyphs; ++index )
- {
- // Convert the character in the visual order into the glyph in the visual order.
- GlyphIndex glyphIndex = 1u + *( layoutParameters.charactersToGlyphsBuffer + characterVisualIndex + index ) - numberOfGlyphs;
+ /**
+ * @brief Updates the text layout with the last laid-out line.
+ *
+ * @param[in] layoutParameters The parameters needed to layout the text.
+ * @param[in] characterIndex The character index of the line.
+ * @param[in] glyphIndex The glyph index of the line.
+ * @param[in,out] layoutSize The text's layout size.
+ * @param[in,out] linesBuffer Pointer to the line's buffer.
+ * @param[in,out] numberOfLines The number of laid-out lines.
+ */
+ void UpdateTextLayout( const Parameters& layoutParameters,
+ CharacterIndex characterIndex,
+ GlyphIndex glyphIndex,
+ Size& layoutSize,
+ LineRun* linesBuffer,
+ Length& numberOfLines )
+ {
+ // Need to add a new line with no characters but with height to increase the layoutSize.height
+ const GlyphInfo& glyphInfo = *( layoutParameters.glyphsBuffer + layoutParameters.totalNumberOfGlyphs - 1u );
+
+ Text::FontMetrics fontMetrics;
+ mMetrics->GetFontMetrics( glyphInfo.fontId, fontMetrics );
+
+ LineRun& lineRun = *( linesBuffer + numberOfLines );
+ ++numberOfLines;
+
+ lineRun.glyphRun.glyphIndex = glyphIndex;
+ lineRun.glyphRun.numberOfGlyphs = 0u;
+ lineRun.characterRun.characterIndex = characterIndex;
+ lineRun.characterRun.numberOfCharacters = 0u;
+ lineRun.width = 0.f;
+ lineRun.ascender = fontMetrics.ascender;
+ lineRun.descender = fontMetrics.descender;
+ lineRun.extraLength = 0.f;
+ lineRun.alignmentOffset = 0.f;
+ lineRun.direction = !RTL;
+ lineRun.ellipsis = false;
+
+ layoutSize.height += ( lineRun.ascender + -lineRun.descender );
+ }
- const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + glyphIndex );
- Vector2& position = *( glyphPositionsBuffer + glyphIndex );
+ /**
+ * @brief Updates the text's layout size adding the size of the previously laid-out lines.
+ *
+ * @param[in] lines The vector of lines (before the new laid-out lines are inserted).
+ * @param[in,out] layoutSize The text's layout size.
+ */
+ void UpdateLayoutSize( const Vector<LineRun>& lines,
+ Size& layoutSize )
+ {
+ for( Vector<LineRun>::ConstIterator it = lines.Begin(),
+ endIt = lines.End();
+ it != endIt;
+ ++it )
+ {
+ const LineRun& line = *it;
- position.x = penX + glyph.xBearing;
- penX += glyph.advance;
- }
+ if( line.width > layoutSize.width )
+ {
+ layoutSize.width = line.width;
}
+
+ layoutSize.height += ( line.ascender + -line.descender );
}
}
- void Align( const LayoutParameters& layoutParameters,
- const Vector<LineRun>& lines,
- Vector<Vector2>& glyphPositions )
+ /**
+ * @brief Updates the indices of the character and glyph runs of the lines before the new lines are inserted.
+ *
+ * @param[in] layoutParameters The parameters needed to layout the text.
+ * @param[in,out] lines The vector of lines (before the new laid-out lines are inserted).
+ * @param[in] characterOffset The offset to be added to the runs of characters.
+ * @param[in] glyphOffset The offset to be added to the runs of glyphs.
+ */
+ void UpdateLineIndexOffsets( const Parameters& layoutParameters,
+ Vector<LineRun>& lines,
+ Length characterOffset,
+ Length glyphOffset )
{
- Vector2* glyphPositionsBuffer = glyphPositions.Begin();
-
- // Traverse all lines and align the glyphs.
- // LayoutParameters contains bidirectional info for those lines with
- // right to left text, this info includes the paragraph's direction.
-
- LineIndex bidiLineIndex = 0u;
- for( Vector<LineRun>::ConstIterator it = lines.Begin(), endIt = lines.End();
+ // Update the glyph and character runs.
+ for( Vector<LineRun>::Iterator it = lines.Begin() + layoutParameters.startLineIndex,
+ endIt = lines.End();
it != endIt;
++it )
{
- const LineRun& line = *it;
+ LineRun& line = *it;
- // 1) Get the paragrap's direction.
- bool paragraphDirection = false;
+ line.glyphRun.glyphIndex = glyphOffset;
+ line.characterRun.characterIndex = characterOffset;
- // Check if there is any right to left line.
- if( ( NULL != layoutParameters.lineBidirectionalInfoRunsBuffer ) &&
- ( bidiLineIndex < layoutParameters.numberOfBidirectionalInfoRuns ) )
- {
- const BidirectionalLineInfoRun* bidiLine = layoutParameters.lineBidirectionalInfoRunsBuffer + bidiLineIndex;
+ glyphOffset += line.glyphRun.numberOfGlyphs;
+ characterOffset += line.characterRun.numberOfCharacters;
+ }
+ }
- // Get the right to left line that match with current line.
- while( ( line.characterRun.characterIndex > bidiLine->characterRun.characterIndex ) &&
- ( bidiLineIndex < layoutParameters.numberOfBidirectionalInfoRuns ) )
- {
- ++bidiLineIndex;
- bidiLine = layoutParameters.lineBidirectionalInfoRunsBuffer + bidiLineIndex;
- }
+ bool LayoutText( const Parameters& layoutParameters,
+ Vector<Vector2>& glyphPositions,
+ Vector<LineRun>& lines,
+ Size& layoutSize,
+ bool elideTextEnabled )
+ {
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->LayoutText\n" );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " box size %f, %f\n", layoutParameters.boundingBox.width, layoutParameters.boundingBox.height );
- if( line.characterRun.characterIndex == bidiLine->characterRun.characterIndex )
+ if( 0u == layoutParameters.numberOfGlyphs )
+ {
+ // Add an extra line if the last character is a new paragraph character and the last line doesn't have zero characters.
+ if( layoutParameters.isLastNewParagraph )
+ {
+ Length numberOfLines = lines.Count();
+ if( 0u != numberOfLines )
{
- paragraphDirection = bidiLine->direction;
+ const LineRun& lastLine = *( lines.End() - 1u );
+
+ if( 0u != lastLine.characterRun.numberOfCharacters )
+ {
+ // Need to add a new line with no characters but with height to increase the layoutSize.height
+ LineRun newLine;
+ Initialize( newLine );
+ lines.PushBack( newLine );
+
+ UpdateTextLayout( layoutParameters,
+ lastLine.characterRun.characterIndex + lastLine.characterRun.numberOfCharacters,
+ lastLine.glyphRun.glyphIndex + lastLine.glyphRun.numberOfGlyphs,
+ layoutSize,
+ lines.Begin(),
+ numberOfLines );
+ }
}
}
- // 2) Calculate the alignment offset accordingly with the align option,
- // the box width, line length, and the paragraphs direction.
- float alignOffset = CalculateAlignment( layoutParameters.boundingBox.width,
- line.lineSize.width,
- line.extraLength,
- paragraphDirection );
-
- // 3) Traverse all glyphs and update the 'x' position.
- for( GlyphIndex index = line.glyphIndex,
- endIndex = line.glyphIndex + line.numberOfGlyphs;
- index < endIndex;
- ++index )
- {
- Vector2& position = *( glyphPositionsBuffer + index );
+ // Calculates the layout size.
+ UpdateLayoutSize( lines,
+ layoutSize );
- position.x += alignOffset;
- }
+ // Nothing else do if there are no glyphs to layout.
+ return false;
}
- }
- bool SingleLineLayout( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
- Size& actualSize )
- {
- LineLayout layout;
- layout.glyphIndex = 0u;
- GetLineLayoutForBox( layoutParameters,
- layout );
+ const GlyphIndex lastGlyphPlusOne = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs;
- // Create a line run and add it to the lines.
- const GlyphIndex lastGlyphIndex = layoutParameters.totalNumberOfGlyphs - 1u;
+ // In a previous layout, an extra line with no characters may have been added if the text ended with a new paragraph character.
+ // This extra line needs to be removed.
+ if( 0u != lines.Count() )
+ {
+ Vector<LineRun>::Iterator lastLine = lines.End() - 1u;
- LineRun lineRun;
- lineRun.glyphIndex = 0u;
- lineRun.numberOfGlyphs = layoutParameters.totalNumberOfGlyphs;
- lineRun.characterRun.characterIndex = 0u;
- lineRun.characterRun.numberOfCharacters = *( layoutParameters.glyphsToCharactersBuffer + lastGlyphIndex ) + *( layoutParameters.charactersPerGlyphBuffer + lastGlyphIndex );
- lineRun.lineSize.width = layout.length;
- lineRun.lineSize.height = layout.height;
- lineRun.extraLength = layout.wsLengthEndOfLine;
+ if( ( 0u == lastLine->characterRun.numberOfCharacters ) &&
+ ( lastGlyphPlusOne == layoutParameters.totalNumberOfGlyphs ) )
+ {
+ lines.Remove( lastLine );
+ }
+ }
- lines.PushBack( lineRun );
+ // Set the first paragraph's direction.
+ CharacterDirection paragraphDirection = ( NULL != layoutParameters.characterDirectionBuffer ) ? *layoutParameters.characterDirectionBuffer : !RTL;
- // Update the actual size.
- actualSize.width = layout.length;
- actualSize.height = layout.height;
+ // Whether the layout is being updated or set from scratch.
+ const bool updateCurrentBuffer = layoutParameters.numberOfGlyphs < layoutParameters.totalNumberOfGlyphs;
+
+ Vector2* glyphPositionsBuffer = NULL;
+ Vector<Vector2> newGlyphPositions;
- float penX = 0.f;
- float penY = layout.height;
+ LineRun* linesBuffer = NULL;
+ Vector<LineRun> newLines;
- Vector2* glyphPositionsBuffer = glyphPositions.Begin();
- for( GlyphIndex glyphIndex = 0u; glyphIndex < layout.numberOfGlyphs; ++glyphIndex )
+ // Estimate the number of lines.
+ Length linesCapacity = std::max( 1u, layoutParameters.estimatedNumberOfLines );
+ Length numberOfLines = 0u;
+
+ if( updateCurrentBuffer )
{
- const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + glyphIndex );
- Vector2& position = *( glyphPositionsBuffer + glyphIndex );
+ newGlyphPositions.Resize( layoutParameters.numberOfGlyphs );
+ glyphPositionsBuffer = newGlyphPositions.Begin();
- position.x = penX + glyph.xBearing;
- position.y = penY - glyph.yBearing;
+ newLines.Resize( linesCapacity );
+ linesBuffer = newLines.Begin();
+ }
+ else
+ {
+ glyphPositionsBuffer = glyphPositions.Begin();
- penX += glyph.advance;
+ lines.Resize( linesCapacity );
+ linesBuffer = lines.Begin();
}
- return true;
- }
+ float penY = CalculateLineOffset( lines,
+ layoutParameters.startLineIndex );
- bool MultiLineLayout( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
- Size& actualSize )
- {
- float penY = 0.f;
- for( GlyphIndex index = 0u; index < layoutParameters.totalNumberOfGlyphs; )
+ for( GlyphIndex index = layoutParameters.startGlyphIndex; index < lastGlyphPlusOne; )
{
- float penX = 0.f;
+ CharacterDirection currentParagraphDirection = paragraphDirection;
// Get the layout for the line.
LineLayout layout;
layout.glyphIndex = index;
- GetMultiLineLayoutForBox( layoutParameters,
- layout );
+ GetLineLayoutForBox( layoutParameters,
+ layout,
+ paragraphDirection,
+ false );
+
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index %d\n", layout.glyphIndex );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " character index %d\n", layout.characterIndex );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " number of glyphs %d\n", layout.numberOfGlyphs );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " number of characters %d\n", layout.numberOfCharacters );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " length %f\n", layout.length );
if( 0u == layout.numberOfGlyphs )
{
// The width is too small and no characters are laid-out.
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--LayoutText width too small!\n\n" );
+
+ lines.Resize( numberOfLines );
return false;
}
- // Create a line run and add it to the lines.
- const GlyphIndex lastGlyphIndex = index + layout.numberOfGlyphs - 1u;
+ // Set the line position. Discard if ellipsis is enabled and the position exceeds the boundaries
+ // of the box.
+ penY += layout.ascender;
- LineRun lineRun;
- lineRun.glyphIndex = index;
- lineRun.numberOfGlyphs = layout.numberOfGlyphs;
- lineRun.characterRun.characterIndex = *( layoutParameters.glyphsToCharactersBuffer + index );
- lineRun.characterRun.numberOfCharacters = ( *( layoutParameters.glyphsToCharactersBuffer + lastGlyphIndex ) + *( layoutParameters.charactersPerGlyphBuffer + lastGlyphIndex ) ) - lineRun.characterRun.characterIndex;
- lineRun.lineSize.width = layout.length;
- lineRun.lineSize.height = layout.height;
- lineRun.extraLength = layout.wsLengthEndOfLine;
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, " pen y %f\n", penY );
- lines.PushBack( lineRun );
+ bool ellipsis = false;
+ if( elideTextEnabled )
+ {
+ // Does the ellipsis of the last line.
+ ellipsis = EllipsisLine( layoutParameters,
+ layout,
+ layoutSize,
+ linesBuffer,
+ glyphPositionsBuffer,
+ numberOfLines,
+ penY,
+ currentParagraphDirection );
+ }
- // Update the actual size.
- if( layout.length > actualSize.width )
+ if( ellipsis )
{
- actualSize.width = layout.length;
+ // No more lines to layout.
+ break;
}
+ else
+ {
+ // Whether the last line has been laid-out.
+ const bool isLastLine = index + layout.numberOfGlyphs == layoutParameters.totalNumberOfGlyphs;
- actualSize.height += layout.height;
+ if( numberOfLines == linesCapacity )
+ {
+ // Reserve more space for the next lines.
+ linesBuffer = ResizeLinesBuffer( lines,
+ newLines,
+ linesCapacity,
+ updateCurrentBuffer );
+ }
- // Traverse the glyphs and set the positions.
+ // Updates the current text's layout with the line's layout.
+ UpdateTextLayout( layoutParameters,
+ layout,
+ layoutSize,
+ linesBuffer,
+ index,
+ numberOfLines,
+ isLastLine );
- penY += layout.height;
+ const GlyphIndex nextIndex = index + layout.numberOfGlyphs;
- Vector2* glyphPositionsBuffer = glyphPositions.Begin();
- for( GlyphIndex i = index; i < index + layout.numberOfGlyphs; ++i )
+ if( ( nextIndex == layoutParameters.totalNumberOfGlyphs ) &&
+ layoutParameters.isLastNewParagraph &&
+ ( mLayout == MULTI_LINE_BOX ) )
+ {
+ // The last character of the text is a new paragraph character.
+ // An extra line with no characters is added to increase the text's height
+ // in order to place the cursor.
+
+ if( numberOfLines == linesCapacity )
+ {
+ // Reserve more space for the next lines.
+ linesBuffer = ResizeLinesBuffer( lines,
+ newLines,
+ linesCapacity,
+ updateCurrentBuffer );
+ }
+
+ UpdateTextLayout( layoutParameters,
+ layout.characterIndex + layout.numberOfCharacters,
+ index + layout.numberOfGlyphs,
+ layoutSize,
+ linesBuffer,
+ numberOfLines );
+ } // whether to add a last line.
+
+ // Sets the positions of the glyphs.
+ SetGlyphPositions( layoutParameters.glyphsBuffer + index,
+ layout.numberOfGlyphs,
+ layoutParameters.outlineWidth,
+ glyphPositionsBuffer + index - layoutParameters.startGlyphIndex );
+
+ // Updates the vertical pen's position.
+ penY += -layout.descender;
+
+ // Increase the glyph index.
+ index = nextIndex;
+ } // no ellipsis
+ } // end for() traversing glyphs.
+
+ if( updateCurrentBuffer )
+ {
+ glyphPositions.Insert( glyphPositions.Begin() + layoutParameters.startGlyphIndex,
+ newGlyphPositions.Begin(),
+ newGlyphPositions.End() );
+ glyphPositions.Resize( layoutParameters.totalNumberOfGlyphs );
+
+ newLines.Resize( numberOfLines );
+
+ // Current text's layout size adds only the newly laid-out lines.
+ // Updates the layout size with the previously laid-out lines.
+ UpdateLayoutSize( lines,
+ layoutSize );
+
+ if( 0u != newLines.Count() )
{
- const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + i );
- Vector2& position = *( glyphPositionsBuffer + i );
+ const LineRun& lastLine = *( newLines.End() - 1u );
- position.x = penX + glyph.xBearing;
- position.y = penY - glyph.yBearing;
+ const Length characterOffset = lastLine.characterRun.characterIndex + lastLine.characterRun.numberOfCharacters;
+ const Length glyphOffset = lastLine.glyphRun.glyphIndex + lastLine.glyphRun.numberOfGlyphs;
- penX += glyph.advance;
- }
+ // Update the indices of the runs before the new laid-out lines are inserted.
+ UpdateLineIndexOffsets( layoutParameters,
+ lines,
+ characterOffset,
+ glyphOffset );
- // Increase the glyph index.
- index += layout.numberOfGlyphs;
+ // Insert the lines.
+ lines.Insert( lines.Begin() + layoutParameters.startLineIndex,
+ newLines.Begin(),
+ newLines.End() );
+ }
}
+ else
+ {
+ lines.Resize( numberOfLines );
+ }
+
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--LayoutText\n\n" );
return true;
}
- float CalculateAlignment( float boxWidth,
- float lineLength,
- float extraLength,
- bool paragraphDirection )
+ void ReLayoutRightToLeftLines( const Parameters& layoutParameters,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Vector<Vector2>& glyphPositions )
{
- float offset = 0.f;
+ const CharacterIndex lastCharacterIndex = startIndex + numberOfCharacters;
- Alignment alignment = mAlignment;
- if( paragraphDirection &&
- ( ALIGN_CENTER != alignment ) )
+ // Traverses the paragraphs with right to left characters.
+ for( LineIndex lineIndex = 0u; lineIndex < layoutParameters.numberOfBidirectionalInfoRuns; ++lineIndex )
{
- if( ALIGN_BEGIN == alignment )
+ const BidirectionalLineInfoRun& bidiLine = *( layoutParameters.lineBidirectionalInfoRunsBuffer + lineIndex );
+
+ if( startIndex >= bidiLine.characterRun.characterIndex + bidiLine.characterRun.numberOfCharacters )
{
- alignment = ALIGN_END;
+ // Do not reorder the line if it has been already reordered.
+ continue;
}
- else
+
+ if( bidiLine.characterRun.characterIndex >= lastCharacterIndex )
{
- alignment = ALIGN_BEGIN;
+ // Do not reorder the lines after the last requested character.
+ break;
+ }
+
+ const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *bidiLine.visualToLogicalMap;
+ const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + *( layoutParameters.charactersToGlyphsBuffer + characterVisualIndex ) );
+
+ float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing - layoutParameters.outlineWidth : -layoutParameters.outlineWidth;
+
+ Vector2* glyphPositionsBuffer = glyphPositions.Begin();
+
+ // Traverses the characters of the right to left paragraph.
+ for( CharacterIndex characterLogicalIndex = 0u;
+ characterLogicalIndex < bidiLine.characterRun.numberOfCharacters;
+ ++characterLogicalIndex )
+ {
+ // Convert the character in the logical order into the character in the visual order.
+ const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *( bidiLine.visualToLogicalMap + characterLogicalIndex );
+
+ // Get the number of glyphs of the character.
+ const Length numberOfGlyphs = *( layoutParameters.glyphsPerCharacterBuffer + characterVisualIndex );
+
+ for( GlyphIndex index = 0u; index < numberOfGlyphs; ++index )
+ {
+ // Convert the character in the visual order into the glyph in the visual order.
+ const GlyphIndex glyphIndex = *( layoutParameters.charactersToGlyphsBuffer + characterVisualIndex ) + index;
+
+ DALI_ASSERT_DEBUG( 0u <= glyphIndex && glyphIndex < layoutParameters.totalNumberOfGlyphs );
+
+ const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + glyphIndex );
+ Vector2& position = *( glyphPositionsBuffer + glyphIndex );
+
+ position.x = penX + glyph.xBearing;
+ penX += glyph.advance;
+ }
}
}
+ }
- switch( alignment )
+ void Align( const Size& size,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Text::HorizontalAlignment::Type horizontalAlignment,
+ Vector<LineRun>& lines,
+ float& alignmentOffset )
+ {
+ const CharacterIndex lastCharacterPlusOne = startIndex + numberOfCharacters;
+
+ alignmentOffset = MAX_FLOAT;
+ // Traverse all lines and align the glyphs.
+ for( Vector<LineRun>::Iterator it = lines.Begin(), endIt = lines.End();
+ it != endIt;
+ ++it )
{
- case ALIGN_BEGIN:
+ LineRun& line = *it;
+
+ if( line.characterRun.characterIndex < startIndex )
{
- offset = 0.f;
- break;
+ // Do not align lines which have already been aligned.
+ continue;
}
- case ALIGN_CENTER:
+
+ if( line.characterRun.characterIndex >= lastCharacterPlusOne )
{
- offset = 0.5f * ( boxWidth - lineLength );
- const int intOffset = static_cast<int>( offset ); // try to avoid pixel alignment.
- offset = static_cast<float>( intOffset );
+ // Do not align lines beyond the last laid-out character.
break;
}
- case ALIGN_END:
+
+ // Calculate the line's alignment offset accordingly with the align option,
+ // the box width, line length, and the paragraph's direction.
+ CalculateHorizontalAlignment( size.width,
+ horizontalAlignment,
+ line );
+
+ // Updates the alignment offset.
+ alignmentOffset = std::min( alignmentOffset, line.alignmentOffset );
+ }
+ }
+
+ void CalculateHorizontalAlignment( float boxWidth,
+ HorizontalAlignment::Type horizontalAlignment,
+ LineRun& line )
+ {
+ line.alignmentOffset = 0.f;
+ const bool isRTL = RTL == line.direction;
+ float lineLength = line.width;
+
+ HorizontalAlignment::Type alignment = horizontalAlignment;
+ if( isRTL )
+ {
+ // Swap the alignment type if the line is right to left.
+ switch( alignment )
{
- offset = boxWidth - lineLength;
- break;
+ case HorizontalAlignment::BEGIN:
+ {
+ alignment = HorizontalAlignment::END;
+ break;
+ }
+ case HorizontalAlignment::CENTER:
+ {
+ // Nothing to do.
+ break;
+ }
+ case HorizontalAlignment::END:
+ {
+ alignment = HorizontalAlignment::BEGIN;
+ break;
+ }
}
}
- if( paragraphDirection )
+ // Calculate the horizontal line offset.
+ switch( alignment )
{
- offset -= extraLength;
+ case HorizontalAlignment::BEGIN:
+ {
+ line.alignmentOffset = 0.f;
+
+ if( isRTL )
+ {
+ // 'Remove' the white spaces at the end of the line (which are at the beginning in visual order)
+ line.alignmentOffset -= line.extraLength;
+ }
+ break;
+ }
+ case HorizontalAlignment::CENTER:
+ {
+ line.alignmentOffset = 0.5f * ( boxWidth - lineLength );
+
+ if( isRTL )
+ {
+ line.alignmentOffset -= line.extraLength;
+ }
+
+ line.alignmentOffset = floorf( line.alignmentOffset ); // try to avoid pixel alignment.
+ break;
+ }
+ case HorizontalAlignment::END:
+ {
+ if( isRTL )
+ {
+ lineLength += line.extraLength;
+ }
+
+ line.alignmentOffset = boxWidth - lineLength;
+ break;
+ }
}
+ }
- return offset;
+ void Initialize( LineRun& line )
+ {
+ line.glyphRun.glyphIndex = 0u;
+ line.glyphRun.numberOfGlyphs = 0u;
+ line.characterRun.characterIndex = 0u;
+ line.characterRun.numberOfCharacters = 0u;
+ line.width = 0.f;
+ line.ascender = 0.f;
+ line.descender = 0.f;
+ line.extraLength = 0.f;
+ line.alignmentOffset = 0.f;
+ line.direction = !RTL;
+ line.ellipsis = false;
}
- LayoutEngine::Layout mLayout;
- LayoutEngine::Alignment mAlignment;
+ Type mLayout;
+ float mCursorWidth;
+ float mDefaultLineSpacing;
- TextAbstraction::FontClient mFontClient;
+ IntrusivePtr<Metrics> mMetrics;
};
-LayoutEngine::LayoutEngine()
+Engine::Engine()
: mImpl( NULL )
{
- mImpl = new LayoutEngine::Impl();
+ mImpl = new Engine::Impl();
}
-LayoutEngine::~LayoutEngine()
+Engine::~Engine()
{
delete mImpl;
}
-void LayoutEngine::SetLayout( Layout layout )
+void Engine::SetMetrics( MetricsPtr& metrics )
+{
+ mImpl->mMetrics = metrics;
+}
+
+void Engine::SetLayout( Type layout )
{
mImpl->mLayout = layout;
}
-unsigned int LayoutEngine::GetLayout() const
+Engine::Type Engine::GetLayout() const
{
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetLayout[%d]\n", mImpl->mLayout);
return mImpl->mLayout;
}
-void LayoutEngine::SetAlignment( Alignment alignment )
+void Engine::SetCursorWidth( int width )
{
- mImpl->mAlignment = alignment;
+ mImpl->mCursorWidth = static_cast<float>( width );
}
-LayoutEngine::Alignment LayoutEngine::GetAlignment() const
+int Engine::GetCursorWidth() const
{
- return mImpl->mAlignment;
+ return static_cast<int>( mImpl->mCursorWidth );
}
-bool LayoutEngine::LayoutText( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
- Size& actualSize )
+bool Engine::LayoutText( const Parameters& layoutParameters,
+ Vector<Vector2>& glyphPositions,
+ Vector<LineRun>& lines,
+ Size& layoutSize,
+ bool elideTextEnabled )
{
return mImpl->LayoutText( layoutParameters,
glyphPositions,
lines,
- actualSize );
+ layoutSize,
+ elideTextEnabled );
}
-void LayoutEngine::ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions )
+void Engine::ReLayoutRightToLeftLines( const Parameters& layoutParameters,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Vector<Vector2>& glyphPositions )
{
mImpl->ReLayoutRightToLeftLines( layoutParameters,
+ startIndex,
+ numberOfCharacters,
glyphPositions );
}
-void LayoutEngine::Align( const LayoutParameters& layoutParameters,
- const Vector<LineRun>& lines,
- Vector<Vector2>& glyphPositions )
+void Engine::Align( const Size& size,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Text::HorizontalAlignment::Type horizontalAlignment,
+ Vector<LineRun>& lines,
+ float& alignmentOffset )
{
- mImpl->Align( layoutParameters,
+ mImpl->Align( size,
+ startIndex,
+ numberOfCharacters,
+ horizontalAlignment,
lines,
- glyphPositions );
+ alignmentOffset );
}
+void Engine::SetDefaultLineSpacing( float lineSpacing )
+{
+ mImpl->mDefaultLineSpacing = lineSpacing;
+}
+
+float Engine::GetDefaultLineSpacing() const
+{
+ return mImpl->mDefaultLineSpacing;
+}
+
+} // namespace Layout
+
} // namespace Text
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff