/*
- * 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.
// EXTERNAL INCLUDES
#include <limits>
-#include <dali/public-api/math/vector2.h>
-#include <dali/public-api/text-abstraction/font-client.h>
#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
{
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
numberOfGlyphs( 0u ),
numberOfCharacters( 0u ),
length( 0.f ),
- widthAdvanceDiff( 0.f ),
+ extraBearing( 0.f ),
+ extraWidth( 0.f ),
wsLengthEndOfLine( 0.f ),
ascender( 0.f ),
- descender( MAX_FLOAT )
+ descender( MAX_FLOAT ),
+ lineSpacing( 0.f )
{}
~LineLayout()
numberOfGlyphs = 0u;
numberOfCharacters = 0u;
length = 0.f;
- widthAdvanceDiff = 0.f;
+ extraBearing = 0.f;
+ extraWidth = 0.f;
wsLengthEndOfLine = 0.f;
ascender = 0.f;
descender = MAX_FLOAT;
CharacterIndex characterIndex; ///< Index of the first character to be laid-out.
Length numberOfGlyphs; ///< The number of glyph which fit in one line.
Length numberOfCharacters; ///< The number of characters which fit in one line.
- float length; ///< The length of the glyphs which fit in one line.
- float widthAdvanceDiff; ///< The difference between the xBearing + width and the advance of the last glyph.
+ 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 ascender; ///< The maximum ascender of all fonts in the line.
float descender; ///< The minimum descender of all fonts in the line.
+ float lineSpacing; ///< The line spacing
};
-struct LayoutEngine::Impl
+struct Engine::Impl
{
Impl()
- : mLayout( LayoutEngine::SINGLE_LINE_BOX ),
- mHorizontalAlignment( LayoutEngine::HORIZONTAL_ALIGN_BEGIN ),
- mVerticalAlignment( LayoutEngine::VERTICAL_ALIGN_TOP ),
- mEllipsisEnabled( false )
+ : mLayout( Layout::Engine::SINGLE_LINE_BOX ),
+ mCursorWidth( CURSOR_WIDTH ),
+ mDefaultLineSpacing( LINE_SPACING ),
+ mPreviousCharacterExtraWidth( 0.0f )
{
- mFontClient = TextAbstraction::FontClient::Get();
}
/**
void UpdateLineHeight( FontId fontId, LineLayout& lineLayout )
{
Text::FontMetrics fontMetrics;
- mFontClient.GetFontMetrics( fontId, fontMetrics );
+ mMetrics->GetFontMetrics( fontId, fontMetrics );
// Sets the maximum ascender.
if( fontMetrics.ascender > lineLayout.ascender )
{
lineLayout.descender = fontMetrics.descender;
}
+
+ // set the line spacing
+ lineLayout.lineSpacing = mDefaultLineSpacing;
}
/**
lineLayout.length += lineLayout.wsLengthEndOfLine;
lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine;
- lineLayout.widthAdvanceDiff = tmpLineLayout.widthAdvanceDiff;
}
else
{
/**
* 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 GetLineLayoutForBox( const LayoutParameters& parameters,
+ void GetLineLayoutForBox( const Parameters& parameters,
LineLayout& lineLayout,
+ CharacterDirection& paragraphDirection,
bool completelyFill )
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->GetLineLayoutForBox\n" );
LineLayout tmpLineLayout;
const bool isMultiline = mLayout == MULTI_LINE_BOX;
- const GlyphIndex lastGlyphIndex = parameters.totalNumberOfGlyphs - 1u;
+ const bool isWordLaidOut = parameters.lineWrapMode == Text::LineWrap::WORD;
- // 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 the bearing needs to be substracted to the line length.
- const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + lineLayout.glyphIndex );
- float initialHorizontalBearing = glyphInfo.xBearing;
+ // 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;
- if( RTL == firstCharacterDirection )
- {
- initialHorizontalBearing = -initialHorizontalBearing;
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
+ float tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
- if( 0.f < glyphInfo.xBearing )
- {
- tmpLineLayout.length = glyphInfo.xBearing;
- initialHorizontalBearing = 0.f;
- }
- }
- else
- {
- if( 0.f > glyphInfo.xBearing )
- {
- tmpLineLayout.length = -glyphInfo.xBearing;
- initialHorizontalBearing = 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 = glyphInfo.fontId;
+ FontId lastFontId = glyphMetrics.fontId;
UpdateLineHeight( lastFontId, tmpLineLayout );
- const float boundingBoxWidth = parameters.boundingBox.width - initialHorizontalBearing;
-
bool oneWordLaidOut = false;
for( GlyphIndex glyphIndex = lineLayout.glyphIndex;
- glyphIndex < parameters.totalNumberOfGlyphs;
- ++glyphIndex )
+ glyphIndex < lastGlyphOfParagraphPlusOne; )
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index : %d\n", glyphIndex );
- const bool isLastGlyph = glyphIndex == lastGlyphIndex;
- // Get the glyph info.
- const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + 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 );
-
- // Get the word break info for the current character.
- const WordBreakInfo wordBreakInfo = *( parameters.wordBreakInfoBuffer + characterLastIndex );
+ const LineBreakInfo lineBreakInfo = hasCharacters ? *( parameters.lineBreakInfoBuffer + characterLastIndex ) : TextAbstraction::LINE_NO_BREAK;
// Increase the number of characters.
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 );
// 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 previousTmpWidthAdvanceDiff = tmpLineLayout.widthAdvanceDiff;
+ 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; // The advance is used 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 + glyphInfo.advance;
- if( RTL == firstCharacterDirection )
+ 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 )
{
- tmpLineLayout.widthAdvanceDiff = -glyphInfo.xBearing;
+ 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;
+ tmpExtraWidth = std::max( mPreviousCharacterExtraWidth - glyphMetrics.advance, tmpExtraWidth );
+ }
}
else
{
- tmpLineLayout.widthAdvanceDiff = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance;
+ if( characterDirection != previousCharacterDirection )
+ {
+ if( RTL == characterDirection )
+ {
+ // -->
+ // |lllR |
+
+ const float extraWidth = glyphMetrics.xBearing + glyphMetrics.width - glyphMetrics.advance;
+ tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f;
+ tmpExtraWidth = std::max( mPreviousCharacterExtraWidth - glyphMetrics.advance, tmpExtraWidth );
+ }
+ 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;
+ tmpExtraWidth = std::max( mPreviousCharacterExtraWidth - glyphMetrics.advance, tmpExtraWidth );
+ }
+ }
}
// Clear the white space length at the end of the line.
tmpLineLayout.wsLengthEndOfLine = 0.f;
}
+ // If calculation is end but wsLengthEndOfLine is exist, it means end of text is space.
+ // Merge remained length.
+ if ( !parameters.ignoreSpaceAfterText && glyphIndex == lastGlyphOfParagraphPlusOne-1 && tmpLineLayout.wsLengthEndOfLine > 0 )
+ {
+ tmpLineLayout.length += tmpLineLayout.wsLengthEndOfLine;
+ tmpLineLayout.wsLengthEndOfLine = 0u;
+ }
+
+ // Save the current extra width to compare with the next one
+ mPreviousCharacterExtraWidth = tmpExtraWidth;
+
// Check if the accumulated length fits in the width of the box.
- if( ( completelyFill || isMultiline ) && !isWhiteSpace &&
- ( lineLayout.length + lineLayout.wsLengthEndOfLine + tmpLineLayout.length + tmpLineLayout.widthAdvanceDiff > boundingBoxWidth ) )
+ if( ( completelyFill || isMultiline ) && !(parameters.ignoreSpaceAfterText && 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's with doesn't fit in the control's with. It needs to be split by character.
+ // 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;
+ tmpLineLayout.numberOfGlyphs -= numberOfGLyphsInGroup;
tmpLineLayout.length = previousTmpLineLength;
- tmpLineLayout.widthAdvanceDiff = previousTmpWidthAdvanceDiff;
+ tmpExtraBearing = previousTmpExtraBearing;
+ tmpExtraWidth = previousTmpExtraWidth;
}
// Add part of the word to the line layout.
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Current word does not fit.\n" );
}
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" );
+
+ lineLayout.extraBearing = tmpExtraBearing;
+ lineLayout.extraWidth = tmpExtraWidth;
+
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox.\n" );
+
return;
}
// Must break the line. Update the line layout and return.
MergeLineLayout( lineLayout, tmpLineLayout );
+ // Set the next paragraph's direction.
+ if( !isLastGlyph &&
+ ( NULL != parameters.characterDirectionBuffer ) )
+ {
+ paragraphDirection = *( parameters.characterDirectionBuffer + 1u + characterLastIndex );
+ }
+
+ lineLayout.extraBearing = tmpExtraBearing;
+ lineLayout.extraWidth = tmpExtraWidth;
+
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Must break\n" );
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" );
+
return;
}
if( isMultiline &&
- ( TextAbstraction::WORD_BREAK == wordBreakInfo ) )
+ ( TextAbstraction::LINE_ALLOW_BREAK == lineBreakInfo ) )
{
- oneWordLaidOut = true;
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, " One word laid out\n" );
+ 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.
tmpLineLayout.Clear();
}
- // 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 != glyphInfo.fontId )
- {
- UpdateLineHeight( glyphInfo.fontId, tmpLineLayout );
- lastFontId = glyphInfo.fontId;
- }
+ previousCharacterDirection = characterDirection;
+ glyphIndex += numberOfGLyphsInGroup;
}
+
+ lineLayout.extraBearing = tmpExtraBearing;
+ lineLayout.extraWidth = tmpExtraWidth;
+
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" );
}
void SetGlyphPositions( const GlyphInfo* const glyphsBuffer,
Length numberOfGlyphs,
- float penY,
+ float outlineWidth,
Vector2* glyphPositionsBuffer )
{
// Traverse the glyphs and set the positions.
// 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.
- float penX = 0.f;
const GlyphInfo& glyph = *glyphsBuffer;
- if( 0.f > glyph.xBearing )
- {
- penX = -glyph.xBearing;
- }
+ float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing + outlineWidth : outlineWidth;
+
for( GlyphIndex i = 0u; i < numberOfGlyphs; ++i )
{
Vector2& position = *( glyphPositionsBuffer + i );
position.x = penX + glyph.xBearing;
- position.y = penY - glyph.yBearing;
+ position.y = -glyph.yBearing;
penX += glyph.advance;
}
}
- bool LayoutText( const LayoutParameters& layoutParameters,
+ /**
+ * @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.
+ * @param[in,out] isAutoScrollEnabled If the isAutoScrollEnabled is true and the height of the text exceeds the boundaries of the control the text is elided and the isAutoScrollEnabled is set to false to disable the autoscroll
+ *
+ * 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,
+ bool& isAutoScrollEnabled )
+ {
+ const bool ellipsis = isAutoScrollEnabled ? ( penY - layout.descender > layoutParameters.boundingBox.height ) :
+ ( ( penY - layout.descender > layoutParameters.boundingBox.height ) ||
+ ( ( mLayout == SINGLE_LINE_BOX ) &&
+ ( layout.extraBearing + layout.length + layout.extraWidth > layoutParameters.boundingBox.width ) ) );
+
+ if( ellipsis )
+ {
+ isAutoScrollEnabled = false;
+ // 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 )
+ {
+ // Get the last line and layout it again with the 'completelyFill' flag to true.
+ lineRun = linesBuffer + ( numberOfLines - 1u );
+
+ penY -= layout.ascender - lineRun->descender + lineRun->lineSpacing;
+
+ ellipsisLayout.glyphIndex = lineRun->glyphRun.glyphIndex;
+ }
+ else
+ {
+ // At least there is space reserved for one line.
+ lineRun = linesBuffer;
+
+ lineRun->glyphRun.glyphIndex = 0u;
+ ellipsisLayout.glyphIndex = 0u;
+
+ ++numberOfLines;
+ }
+
+ 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 ) + lineRun->lineSpacing;
+ }
+
+ SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun->glyphRun.glyphIndex,
+ ellipsisLayout.numberOfGlyphs,
+ layoutParameters.outlineWidth,
+ glyphPositionsBuffer + lineRun->glyphRun.glyphIndex - layoutParameters.startGlyphIndex );
+ }
+
+ return ellipsis;
+ }
+
+ /**
+ * @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 )
+ {
+ LineRun& lineRun = *( linesBuffer + numberOfLines );
+ ++numberOfLines;
+
+ lineRun.glyphRun.glyphIndex = index;
+ lineRun.glyphRun.numberOfGlyphs = layout.numberOfGlyphs;
+ lineRun.characterRun.characterIndex = layout.characterIndex;
+ lineRun.characterRun.numberOfCharacters = layout.numberOfCharacters;
+ lineRun.lineSpacing = mDefaultLineSpacing;
+
+ if( isLastLine && !layoutParameters.isLastNewParagraph )
+ {
+ 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;
+ }
+
+ 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;
+
+ // Update the actual size.
+ if( lineRun.width > layoutSize.width )
+ {
+ layoutSize.width = lineRun.width;
+ }
+
+ layoutSize.height += ( lineRun.ascender + -lineRun.descender ) + lineRun.lineSpacing;
+ }
+
+ /**
+ * @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;
+ lineRun.lineSpacing = mDefaultLineSpacing;
+
+ layoutSize.height += ( lineRun.ascender + -lineRun.descender ) + lineRun.lineSpacing;
+ }
+
+ /**
+ * @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;
+
+ if( line.width > layoutSize.width )
+ {
+ layoutSize.width = line.width;
+ }
+
+ layoutSize.height += ( line.ascender + -line.descender ) + line.lineSpacing;
+ }
+ }
+
+ /**
+ * @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 )
+ {
+ // Update the glyph and character runs.
+ for( Vector<LineRun>::Iterator it = lines.Begin() + layoutParameters.startLineIndex,
+ endIt = lines.End();
+ it != endIt;
+ ++it )
+ {
+ LineRun& line = *it;
+
+ line.glyphRun.glyphIndex = glyphOffset;
+ line.characterRun.characterIndex = characterOffset;
+
+ glyphOffset += line.glyphRun.numberOfGlyphs;
+ characterOffset += line.characterRun.numberOfCharacters;
+ }
+ }
+
+ bool LayoutText( const Parameters& layoutParameters,
Vector<Vector2>& glyphPositions,
Vector<LineRun>& lines,
- Size& actualSize )
+ Size& layoutSize,
+ bool elideTextEnabled,
+ bool& isAutoScrollEnabled )
{
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 );
- float penY = 0.f;
- for( GlyphIndex index = 0u; index < layoutParameters.totalNumberOfGlyphs; )
+ 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 )
+ {
+ 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 );
+ }
+ }
+ }
+
+ // Calculates the layout size.
+ UpdateLayoutSize( lines,
+ layoutSize );
+
+ // Nothing else do if there are no glyphs to layout.
+ return false;
+ }
+
+ const GlyphIndex lastGlyphPlusOne = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs;
+
+ // 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;
+
+ if( ( 0u == lastLine->characterRun.numberOfCharacters ) &&
+ ( lastGlyphPlusOne == layoutParameters.totalNumberOfGlyphs ) )
+ {
+ lines.Remove( lastLine );
+ }
+ }
+
+ // Set the first paragraph's direction.
+ CharacterDirection paragraphDirection = ( NULL != layoutParameters.characterDirectionBuffer ) ? *layoutParameters.characterDirectionBuffer : !RTL;
+
+ // Whether the layout is being updated or set from scratch.
+ const bool updateCurrentBuffer = layoutParameters.numberOfGlyphs < layoutParameters.totalNumberOfGlyphs;
+
+ Vector2* glyphPositionsBuffer = NULL;
+ Vector<Vector2> newGlyphPositions;
+
+ LineRun* linesBuffer = NULL;
+ Vector<LineRun> newLines;
+
+ // Estimate the number of lines.
+ Length linesCapacity = std::max( 1u, layoutParameters.estimatedNumberOfLines );
+ Length numberOfLines = 0u;
+
+ if( updateCurrentBuffer )
+ {
+ newGlyphPositions.Resize( layoutParameters.numberOfGlyphs );
+ glyphPositionsBuffer = newGlyphPositions.Begin();
+
+ newLines.Resize( linesCapacity );
+ linesBuffer = newLines.Begin();
+ }
+ else
+ {
+ glyphPositionsBuffer = glyphPositions.Begin();
+
+ lines.Resize( linesCapacity );
+ linesBuffer = lines.Begin();
+ }
+
+ float penY = CalculateLineOffset( lines,
+ layoutParameters.startLineIndex );
+
+ for( GlyphIndex index = layoutParameters.startGlyphIndex; index < lastGlyphPlusOne; )
{
+ CharacterDirection currentParagraphDirection = paragraphDirection;
+
// Get the layout for the line.
LineLayout layout;
layout.glyphIndex = index;
GetLineLayoutForBox( layoutParameters,
layout,
+ paragraphDirection,
false );
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index %d\n", layout.glyphIndex );
{
// 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;
}
penY += layout.ascender;
DALI_LOG_INFO( gLogFilter, Debug::Verbose, " pen y %f\n", penY );
- if( mEllipsisEnabled &&
- ( ( penY - layout.descender > layoutParameters.boundingBox.height ) ||
- ( ( mLayout == SINGLE_LINE_BOX ) &&
- ( layout.length + layout.widthAdvanceDiff > layoutParameters.boundingBox.width ) ) ) )
- {
- // 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.
-
- const Length numberOfLines = lines.Count();
- LineRun lineRun;
- LineLayout ellipsisLayout;
- if( 0u != numberOfLines )
- {
- // Get the last line and layout it again with the 'completelyFill' flag to true.
- lineRun = *( lines.Begin() + ( numberOfLines - 1u ) );
+ bool ellipsis = false;
+ if( elideTextEnabled )
+ {
+ // Does the ellipsis of the last line.
+ ellipsis = EllipsisLine( layoutParameters,
+ layout,
+ layoutSize,
+ linesBuffer,
+ glyphPositionsBuffer,
+ numberOfLines,
+ penY,
+ currentParagraphDirection,
+ isAutoScrollEnabled );
+ }
- penY -= layout.ascender - lineRun.descender;
+ if( ellipsis )
+ {
+ // No more lines to layout.
+ break;
+ }
+ else
+ {
+ // Whether the last line has been laid-out.
+ const bool isLastLine = index + layout.numberOfGlyphs == layoutParameters.totalNumberOfGlyphs;
- ellipsisLayout.glyphIndex = lineRun.glyphIndex;
- }
- else
+ if( numberOfLines == linesCapacity )
{
- lineRun.glyphIndex = 0u;
- ellipsisLayout.glyphIndex = 0u;
+ // Reserve more space for the next lines.
+ linesBuffer = ResizeLinesBuffer( lines,
+ newLines,
+ linesCapacity,
+ updateCurrentBuffer );
}
- GetLineLayoutForBox( layoutParameters,
- ellipsisLayout,
- true );
-
- lineRun.numberOfGlyphs = ellipsisLayout.numberOfGlyphs;
- lineRun.characterRun.characterIndex = ellipsisLayout.characterIndex;
- lineRun.characterRun.numberOfCharacters = ellipsisLayout.numberOfCharacters;
- lineRun.width = layoutParameters.boundingBox.width;
- lineRun.ascender = ellipsisLayout.ascender;
- lineRun.descender = ellipsisLayout.descender;
- lineRun.extraLength = ellipsisLayout.wsLengthEndOfLine > 0.f ? ellipsisLayout.wsLengthEndOfLine - ellipsisLayout.widthAdvanceDiff : 0.f;
- lineRun.ellipsis = true;
-
- actualSize.width = layoutParameters.boundingBox.width;
- actualSize.height += ( lineRun.ascender + -lineRun.descender );
+ // Updates the current text's layout with the line's layout.
+ UpdateTextLayout( layoutParameters,
+ layout,
+ layoutSize,
+ linesBuffer,
+ index,
+ numberOfLines,
+ isLastLine );
- SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun.glyphIndex,
- ellipsisLayout.numberOfGlyphs,
- penY,
- glyphPositions.Begin() + lineRun.glyphIndex );
+ const GlyphIndex nextIndex = index + layout.numberOfGlyphs;
- if( 0u != numberOfLines )
- {
- // Set the last line with the ellipsis layout.
- *( lines.Begin() + ( numberOfLines - 1u ) ) = lineRun;
- }
- else
+ if( ( nextIndex == layoutParameters.totalNumberOfGlyphs ) &&
+ layoutParameters.isLastNewParagraph &&
+ ( mLayout == MULTI_LINE_BOX ) )
{
- // Push the line.
- lines.PushBack( lineRun );
- }
+ // 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.
- break;
- }
- else
- {
- LineRun lineRun;
- lineRun.glyphIndex = index;
- lineRun.numberOfGlyphs = layout.numberOfGlyphs;
- lineRun.characterRun.characterIndex = layout.characterIndex;
- lineRun.characterRun.numberOfCharacters = layout.numberOfCharacters;
- lineRun.width = layout.length + layout.widthAdvanceDiff;
- lineRun.ascender = layout.ascender;
- lineRun.descender = layout.descender;
- lineRun.extraLength = layout.wsLengthEndOfLine > 0.f ? layout.wsLengthEndOfLine - layout.widthAdvanceDiff : 0.f;
- lineRun.direction = false;
- lineRun.ellipsis = false;
-
- lines.PushBack( lineRun );
-
- // Update the actual size.
- if( lineRun.width > actualSize.width )
- {
- actualSize.width = lineRun.width;
- }
+ if( numberOfLines == linesCapacity )
+ {
+ // Reserve more space for the next lines.
+ linesBuffer = ResizeLinesBuffer( lines,
+ newLines,
+ linesCapacity,
+ updateCurrentBuffer );
+ }
- actualSize.height += ( lineRun.ascender + -lineRun.descender );
+ 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,
- penY,
- glyphPositions.Begin() + index );
+ layoutParameters.outlineWidth,
+ glyphPositionsBuffer + index - layoutParameters.startGlyphIndex );
- penY += -layout.descender;
+ // Updates the vertical pen's position.
+ penY += -layout.descender + layout.lineSpacing + mDefaultLineSpacing;
// Increase the glyph index.
- index += layout.numberOfGlyphs;
+ 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 LineRun& lastLine = *( newLines.End() - 1u );
+
+ const Length characterOffset = lastLine.characterRun.characterIndex + lastLine.characterRun.numberOfCharacters;
+ const Length glyphOffset = lastLine.glyphRun.glyphIndex + lastLine.glyphRun.numberOfGlyphs;
+
+ // Update the indices of the runs before the new laid-out lines are inserted.
+ UpdateLineIndexOffsets( layoutParameters,
+ lines,
+ characterOffset,
+ glyphOffset );
+
+ // 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;
}
- void ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters,
+ void ReLayoutRightToLeftLines( const Parameters& layoutParameters,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
Vector<Vector2>& glyphPositions )
{
+ const CharacterIndex lastCharacterIndex = startIndex + numberOfCharacters;
+
// Traverses the paragraphs with right to left characters.
for( LineIndex lineIndex = 0u; lineIndex < layoutParameters.numberOfBidirectionalInfoRuns; ++lineIndex )
{
const BidirectionalLineInfoRun& bidiLine = *( layoutParameters.lineBidirectionalInfoRunsBuffer + lineIndex );
- float penX = 0.f;
+ if( startIndex >= bidiLine.characterRun.characterIndex + bidiLine.characterRun.numberOfCharacters )
+ {
+ // Do not reorder the line if it has been already reordered.
+ continue;
+ }
+
+ if( bidiLine.characterRun.characterIndex >= lastCharacterIndex )
+ {
+ // 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 ) );
- penX = -glyph.xBearing;
+ float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing - layoutParameters.outlineWidth : -layoutParameters.outlineWidth;
Vector2* glyphPositionsBuffer = glyphPositions.Begin();
}
}
- void Align( const LayoutParameters& layoutParameters,
- const Size& layoutSize,
- const Vector<LineRun>& lines,
- Vector<Vector2>& glyphPositions )
+ void Align( const Size& size,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Text::HorizontalAlignment::Type horizontalAlignment,
+ Vector<LineRun>& lines,
+ float& alignmentOffset,
+ Dali::LayoutDirection::Type layoutDirection,
+ bool matchSystemLanguageDirection )
{
- Vector2* glyphPositionsBuffer = glyphPositions.Begin();
+ const CharacterIndex lastCharacterPlusOne = startIndex + numberOfCharacters;
+ alignmentOffset = MAX_FLOAT;
// 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();
+ for( Vector<LineRun>::Iterator it = lines.Begin(), endIt = lines.End();
it != endIt;
++it )
{
- const LineRun& line = *it;
-
- // 1) Get the paragrap's direction.
- bool paragraphDirection = false;
+ LineRun& line = *it;
- // Check if there is any right to left line.
- if( ( NULL != layoutParameters.lineBidirectionalInfoRunsBuffer ) &&
- ( bidiLineIndex < layoutParameters.numberOfBidirectionalInfoRuns ) )
+ if( line.characterRun.characterIndex < startIndex )
{
- const BidirectionalLineInfoRun* bidiLine = layoutParameters.lineBidirectionalInfoRunsBuffer + bidiLineIndex;
-
- // 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;
- }
-
- if( line.characterRun.characterIndex == bidiLine->characterRun.characterIndex )
- {
- paragraphDirection = bidiLine->direction;
- }
+ // Do not align lines which have already been aligned.
+ continue;
}
- // 2) Calculate the alignment offset accordingly with the align option,
- // the box width, line length, and the paragraphs direction.
- float alignOffset = CalculateHorizontalAlignment( layoutSize.width,
- line.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 )
+ if( line.characterRun.characterIndex >= lastCharacterPlusOne )
{
- Vector2& position = *( glyphPositionsBuffer + index );
-
- position.x += alignOffset;
+ // Do not align lines beyond the last laid-out character.
+ break;
}
+
+ // 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,
+ layoutDirection,
+ matchSystemLanguageDirection );
+
+ // Updates the alignment offset.
+ alignmentOffset = std::min( alignmentOffset, line.alignmentOffset );
}
}
- float CalculateHorizontalAlignment( float boxWidth,
- float lineLength,
- float extraLength,
- bool paragraphDirection )
+ void CalculateHorizontalAlignment( float boxWidth,
+ HorizontalAlignment::Type horizontalAlignment,
+ LineRun& line,
+ Dali::LayoutDirection::Type layoutDirection,
+ bool matchSystemLanguageDirection )
{
- float offset = 0.f;
-
- HorizontalAlignment alignment = mHorizontalAlignment;
- if( paragraphDirection &&
- ( HORIZONTAL_ALIGN_CENTER != alignment ) )
+ line.alignmentOffset = 0.f;
+ const bool isLineRTL = RTL == line.direction;
+ // Whether to swap the alignment.
+ // Swap if the line is RTL and is not required to match the direction of the system's language or if it's required to match the direction of the system's language and it's RTL.
+ bool isLayoutRTL = isLineRTL;
+ float lineLength = line.width;
+
+ // match align for system language direction
+ if( matchSystemLanguageDirection )
{
- if( HORIZONTAL_ALIGN_BEGIN == alignment )
- {
- alignment = HORIZONTAL_ALIGN_END;
- }
- else
- {
- alignment = HORIZONTAL_ALIGN_BEGIN;
- }
+ // Swap the alignment type if the line is right to left.
+ isLayoutRTL = layoutDirection == LayoutDirection::RIGHT_TO_LEFT;
}
-
- switch( alignment )
+ // Calculate the horizontal line offset.
+ switch( horizontalAlignment )
{
- case HORIZONTAL_ALIGN_BEGIN:
+ case HorizontalAlignment::BEGIN:
{
- offset = 0.f;
+ if( isLayoutRTL )
+ {
+ if( isLineRTL )
+ {
+ lineLength += line.extraLength;
+ }
+
+ line.alignmentOffset = boxWidth - lineLength;
+ }
+ else
+ {
+ line.alignmentOffset = 0.f;
+
+ if( isLineRTL )
+ {
+ // 'Remove' the white spaces at the end of the line (which are at the beginning in visual order)
+ line.alignmentOffset -= line.extraLength;
+ }
+ }
break;
}
- case HORIZONTAL_ALIGN_CENTER:
+ case HorizontalAlignment::CENTER:
{
- offset = 0.5f * ( boxWidth - lineLength );
- const int intOffset = static_cast<int>( offset ); // try to avoid pixel alignment.
- offset = static_cast<float>( intOffset );
+ line.alignmentOffset = 0.5f * ( boxWidth - lineLength );
+
+ if( isLineRTL )
+ {
+ line.alignmentOffset -= line.extraLength;
+ }
+
+ line.alignmentOffset = floorf( line.alignmentOffset ); // try to avoid pixel alignment.
break;
}
- case HORIZONTAL_ALIGN_END:
+ case HorizontalAlignment::END:
{
- offset = boxWidth - lineLength;
+ if( isLayoutRTL )
+ {
+ line.alignmentOffset = 0.f;
+
+ if( isLineRTL )
+ {
+ // 'Remove' the white spaces at the end of the line (which are at the beginning in visual order)
+ line.alignmentOffset -= line.extraLength;
+ }
+ }
+ else
+ {
+ if( isLineRTL )
+ {
+ lineLength += line.extraLength;
+ }
+
+ line.alignmentOffset = boxWidth - lineLength;
+ }
break;
}
}
-
- if( paragraphDirection )
- {
- offset -= extraLength;
- }
-
- return offset;
}
- LayoutEngine::Layout mLayout;
- LayoutEngine::HorizontalAlignment mHorizontalAlignment;
- LayoutEngine::VerticalAlignment mVerticalAlignment;
+ 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;
+ line.lineSpacing = mDefaultLineSpacing;
+ }
- TextAbstraction::FontClient mFontClient;
+ Type mLayout;
+ float mCursorWidth;
+ float mDefaultLineSpacing;
+ float mPreviousCharacterExtraWidth;
- bool mEllipsisEnabled:1;
+ 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->mLayout = layout;
+ mImpl->mMetrics = metrics;
}
-unsigned int LayoutEngine::GetLayout() const
+void Engine::SetLayout( Type layout )
{
- return mImpl->mLayout;
+ mImpl->mLayout = layout;
}
-void LayoutEngine::SetTextEllipsisEnabled( bool enabled )
+Engine::Type Engine::GetLayout() const
{
- mImpl->mEllipsisEnabled = enabled;
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GetLayout[%d]\n", mImpl->mLayout);
+ return mImpl->mLayout;
}
-bool LayoutEngine::GetTextEllipsisEnabled() const
+void Engine::SetCursorWidth( int width )
{
- return mImpl->mEllipsisEnabled;
+ mImpl->mCursorWidth = static_cast<float>( width );
}
-void LayoutEngine::SetHorizontalAlignment( HorizontalAlignment alignment )
+int Engine::GetCursorWidth() const
{
- mImpl->mHorizontalAlignment = alignment;
+ return static_cast<int>( mImpl->mCursorWidth );
}
-LayoutEngine::HorizontalAlignment LayoutEngine::GetHorizontalAlignment() const
+bool Engine::LayoutText( const Parameters& layoutParameters,
+ Vector<Vector2>& glyphPositions,
+ Vector<LineRun>& lines,
+ Size& layoutSize,
+ bool elideTextEnabled,
+ bool& isAutoScrollEnabled )
{
- return mImpl->mHorizontalAlignment;
+ return mImpl->LayoutText( layoutParameters,
+ glyphPositions,
+ lines,
+ layoutSize,
+ elideTextEnabled,
+ isAutoScrollEnabled );
}
-void LayoutEngine::SetVerticalAlignment( VerticalAlignment alignment )
+void Engine::ReLayoutRightToLeftLines( const Parameters& layoutParameters,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Vector<Vector2>& glyphPositions )
{
- mImpl->mVerticalAlignment = alignment;
+ mImpl->ReLayoutRightToLeftLines( layoutParameters,
+ startIndex,
+ numberOfCharacters,
+ glyphPositions );
}
-LayoutEngine::VerticalAlignment LayoutEngine::GetVerticalAlignment() const
+void Engine::Align( const Size& size,
+ CharacterIndex startIndex,
+ Length numberOfCharacters,
+ Text::HorizontalAlignment::Type horizontalAlignment,
+ Vector<LineRun>& lines,
+ float& alignmentOffset,
+ Dali::LayoutDirection::Type layoutDirection,
+ bool matchSystemLanguageDirection )
{
- return mImpl->mVerticalAlignment;
+ mImpl->Align( size,
+ startIndex,
+ numberOfCharacters,
+ horizontalAlignment,
+ lines,
+ alignmentOffset,
+ layoutDirection,
+ matchSystemLanguageDirection );
}
-bool LayoutEngine::LayoutText( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions,
- Vector<LineRun>& lines,
- Size& actualSize )
+void Engine::SetDefaultLineSpacing( float lineSpacing )
{
- return mImpl->LayoutText( layoutParameters,
- glyphPositions,
- lines,
- actualSize );
+ mImpl->mDefaultLineSpacing = lineSpacing;
}
-void LayoutEngine::ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters,
- Vector<Vector2>& glyphPositions )
+float Engine::GetDefaultLineSpacing() const
{
- mImpl->ReLayoutRightToLeftLines( layoutParameters,
- glyphPositions );
+ return mImpl->mDefaultLineSpacing;
}
-void LayoutEngine::Align( const LayoutParameters& layoutParameters,
- const Size& layoutSize,
- const Vector<LineRun>& lines,
- Vector<Vector2>& glyphPositions )
-{
- mImpl->Align( layoutParameters,
- layoutSize,
- lines,
- glyphPositions );
-}
+} // namespace Layout
} // namespace Text
projects / platform / core / uifw / dali-toolkit.git / blobdiff