X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Flayouts%2Flayout-engine.cpp;h=b018ed159081655e936b27edd5ab073500d51908;hp=1a97dd4f794ef48660240b3180b653dcfa73d437;hb=5064025f6246c31c82cd1531084b639ac9c3237d;hpb=4d75bf1bc38c24eb1d968688d094d0ffef2ee946 diff --git a/dali-toolkit/internal/text/layouts/layout-engine.cpp b/dali-toolkit/internal/text/layouts/layout-engine.cpp index 1a97dd4..b018ed1 100644 --- a/dali-toolkit/internal/text/layouts/layout-engine.cpp +++ b/dali-toolkit/internal/text/layouts/layout-engine.cpp @@ -21,7 +21,8 @@ // EXTERNAL INCLUDES #include #include -#include +#include +#include // INTERNAL INCLUDES #include @@ -39,7 +40,12 @@ namespace Text 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::max(); +const bool RTL = true; } //namespace @@ -48,12 +54,40 @@ const float MAX_FLOAT = std::numeric_limits::max(); */ struct LineLayout { + LineLayout() + : glyphIndex( 0u ), + characterIndex( 0u ), + numberOfGlyphs( 0u ), + numberOfCharacters( 0u ), + length( 0.f ), + widthAdvanceDiff( 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; + widthAdvanceDiff = 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. + 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 width and the advance of the last glyph. + float widthAdvanceDiff; ///< The difference between the xBearing + width and the advance of the last glyph. 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. @@ -64,120 +98,133 @@ struct LayoutEngine::Impl Impl() : mLayout( LayoutEngine::SINGLE_LINE_BOX ), mHorizontalAlignment( LayoutEngine::HORIZONTAL_ALIGN_BEGIN ), - mVerticalAlignment( LayoutEngine::VERTICAL_ALIGN_TOP ) + mVerticalAlignment( LayoutEngine::VERTICAL_ALIGN_TOP ), + mEllipsisEnabled( false ) { 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.ascender = 0.f; - lineLayout.descender = MAX_FLOAT; - - // Get the last glyph index. - const GlyphIndex lastGlyphIndex = parameters.totalNumberOfGlyphs - 1u; + Text::FontMetrics fontMetrics; + mFontClient.GetFontMetrics( fontId, fontMetrics ); - FontId lastFontId = 0u; - for( GlyphIndex glyphIndex = lineLayout.glyphIndex; - glyphIndex < parameters.totalNumberOfGlyphs; - ++glyphIndex ) + // Sets the maximum ascender. + if( fontMetrics.ascender > lineLayout.ascender ) { - // Get the glyph info. - const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + glyphIndex ); - - // 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; + 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 ascender. - if( fontMetrics.ascender > lineLayout.ascender ) - { - lineLayout.ascender = fontMetrics.ascender; - } + lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine; + lineLayout.widthAdvanceDiff = tmpLineLayout.widthAdvanceDiff; + } + else + { + lineLayout.wsLengthEndOfLine += tmpLineLayout.wsLengthEndOfLine; + } - // Sets the minimum descender. - if( fontMetrics.descender < lineLayout.descender ) - { - lineLayout.descender = fontMetrics.descender; - } + 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. + * + * @param[in] parameters The layout parameters. + * @param[out] lineLayout The line layout. + * @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 LayoutParameters& parameters, + LineLayout& lineLayout, + bool completelyFill ) { - // Initializes the line layout. - lineLayout.numberOfCharacters = 0u; - lineLayout.numberOfGlyphs = 0u; - lineLayout.length = 0.f; - lineLayout.widthAdvanceDiff = 0.f; - lineLayout.wsLengthEndOfLine = 0.f; - lineLayout.ascender = 0.f; - lineLayout.descender = MAX_FLOAT; - + 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.widthAdvanceDiff = 0.f; - tmpLineLayout.wsLengthEndOfLine = 0.f; - tmpLineLayout.ascender = 0.f; - tmpLineLayout.descender = MAX_FLOAT; - - FontId lastFontId = 0u; + + const bool isMultiline = mLayout == MULTI_LINE_BOX; + const GlyphIndex lastGlyphIndex = parameters.totalNumberOfGlyphs - 1u; + + // 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; + + lineLayout.characterIndex = *( parameters.glyphsToCharactersBuffer + lineLayout.glyphIndex ); + const CharacterDirection firstCharacterDirection = ( NULL == parameters.characterDirectionBuffer ) ? false : *( parameters.characterDirectionBuffer + lineLayout.characterIndex ); + + if( RTL == firstCharacterDirection ) + { + initialHorizontalBearing = -initialHorizontalBearing; + + 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; + } + } + + // Calculate the line height if there is no characters. + FontId lastFontId = glyphInfo.fontId; + UpdateLineHeight( lastFontId, tmpLineLayout ); + + const float boundingBoxWidth = parameters.boundingBox.width - initialHorizontalBearing; + + bool oneWordLaidOut = false; + for( GlyphIndex glyphIndex = lineLayout.glyphIndex; glyphIndex < parameters.totalNumberOfGlyphs; ++glyphIndex ) { + 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 ); @@ -204,127 +251,124 @@ struct LayoutEngine::Impl 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 previousTmpWidthAdvanceDiff = tmpLineLayout.widthAdvanceDiff; + // 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.widthAdvanceDiff = 0.f; + tmpLineLayout.wsLengthEndOfLine += glyphInfo.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; - tmpLineLayout.widthAdvanceDiff = glyphInfo.width - glyphInfo.advance; + if( RTL == firstCharacterDirection ) + { + tmpLineLayout.widthAdvanceDiff = -glyphInfo.xBearing; + } + else + { + tmpLineLayout.widthAdvanceDiff = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance; + } // 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 + tmpLineLayout.widthAdvanceDiff + ( ( 0.f < tmpLineLayout.length ) ? lineLayout.wsLengthEndOfLine : 0.f ) > parameters.boundingBox.width ) + if( ( completelyFill || isMultiline ) && !isWhiteSpace && + ( lineLayout.length + lineLayout.wsLengthEndOfLine + tmpLineLayout.length + tmpLineLayout.widthAdvanceDiff > boundingBoxWidth ) ) { // Current word does not fit in the box's width. - return; - } - - if( 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; - lineLayout.widthAdvanceDiff = tmpLineLayout.widthAdvanceDiff; - - if( 0.f < tmpLineLayout.length ) + if( !oneWordLaidOut || completelyFill ) { - lineLayout.length += lineLayout.wsLengthEndOfLine; - - lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine; + 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. + if( tmpLineLayout.numberOfGlyphs > 0u ) + { + tmpLineLayout.numberOfCharacters -= charactersPerGlyph; + --tmpLineLayout.numberOfGlyphs; + tmpLineLayout.length = previousTmpLineLength; + tmpLineLayout.widthAdvanceDiff = previousTmpWidthAdvanceDiff; + } + + // Add part of the word to the line layout. + MergeLineLayout( lineLayout, tmpLineLayout ); } else { - lineLayout.wsLengthEndOfLine += tmpLineLayout.wsLengthEndOfLine; - } - - if( tmpLineLayout.ascender > lineLayout.ascender ) - { - lineLayout.ascender = tmpLineLayout.ascender; + DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Current word does not fit.\n" ); } + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" ); + return; + } - if( tmpLineLayout.descender < lineLayout.descender ) - { - lineLayout.descender = tmpLineLayout.descender; - } + if( ( isMultiline || isLastGlyph ) && + ( TextAbstraction::LINE_MUST_BREAK == lineBreakInfo ) ) + { + // Must break the line. Update the line layout and return. + MergeLineLayout( lineLayout, tmpLineLayout ); - tmpLineLayout.numberOfCharacters = 0u; - tmpLineLayout.numberOfGlyphs = 0u; - tmpLineLayout.length = 0u; - tmpLineLayout.widthAdvanceDiff = 0u; - tmpLineLayout.wsLengthEndOfLine = 0u; - tmpLineLayout.ascender = 0.f; - tmpLineLayout.descender = MAX_FLOAT; + DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Must break\n" ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" ); return; } - if( TextAbstraction::WORD_BREAK == wordBreakInfo ) + if( isMultiline && + ( TextAbstraction::WORD_BREAK == wordBreakInfo ) ) { + oneWordLaidOut = true; + 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; - lineLayout.widthAdvanceDiff = tmpLineLayout.widthAdvanceDiff; - - if( 0.f < tmpLineLayout.length ) - { - lineLayout.length += lineLayout.wsLengthEndOfLine; - - lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine; - } - else - { - lineLayout.wsLengthEndOfLine += tmpLineLayout.wsLengthEndOfLine; - } - - if( tmpLineLayout.ascender > lineLayout.ascender ) - { - lineLayout.ascender = tmpLineLayout.ascender; - } - - if( tmpLineLayout.descender < lineLayout.descender ) - { - lineLayout.descender = tmpLineLayout.descender; - } + MergeLineLayout( lineLayout, tmpLineLayout ); - tmpLineLayout.numberOfCharacters = 0u; - tmpLineLayout.numberOfGlyphs = 0u; - tmpLineLayout.length = 0u; - tmpLineLayout.widthAdvanceDiff = 0u; - tmpLineLayout.wsLengthEndOfLine = 0u; - tmpLineLayout.ascender = 0.f; - tmpLineLayout.descender = MAX_FLOAT; + 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 ) { - Text::FontMetrics fontMetrics; - mFontClient.GetFontMetrics( glyphInfo.fontId, fontMetrics ); + UpdateLineHeight( glyphInfo.fontId, tmpLineLayout ); + lastFontId = glyphInfo.fontId; + } + } + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" ); + } - // Sets the maximum ascender. - if( fontMetrics.ascender > tmpLineLayout.ascender ) - { - tmpLineLayout.ascender = fontMetrics.ascender; - } + void SetGlyphPositions( const GlyphInfo* const glyphsBuffer, + Length numberOfGlyphs, + float penY, + Vector2* glyphPositionsBuffer ) + { + // Traverse the glyphs and set the positions. - // Sets the minimum descender. - if( -fontMetrics.descender < tmpLineLayout.descender ) - { - tmpLineLayout.descender = fontMetrics.descender; - } + // 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; - lastFontId = glyphInfo.fontId; - } + const GlyphInfo& glyph = *glyphsBuffer; + if( 0.f > glyph.xBearing ) + { + penX = -glyph.xBearing; + } + + for( GlyphIndex i = 0u; i < numberOfGlyphs; ++i ) + { + const GlyphInfo& glyph = *( glyphsBuffer + i ); + Vector2& position = *( glyphPositionsBuffer + i ); + + position.x = penX + glyph.xBearing; + position.y = penY - glyph.yBearing; + + penX += glyph.advance; } } @@ -333,32 +377,139 @@ struct LayoutEngine::Impl Vector& lines, Size& actualSize ) { - // TODO Switch between different layouts - bool update = false; + 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 ); - switch( mLayout ) + float penY = 0.f; + for( GlyphIndex index = 0u; index < layoutParameters.totalNumberOfGlyphs; ) { - case LayoutEngine::SINGLE_LINE_BOX: + // Get the layout for the line. + LineLayout layout; + layout.glyphIndex = index; + GetLineLayoutForBox( layoutParameters, + layout, + 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 ) { - update = SingleLineLayout( layoutParameters, - glyphPositions, - lines, - actualSize ); - break; + // The width is too small and no characters are laid-out. + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--LayoutText width too small!\n\n" ); + return false; } - case LayoutEngine::MULTI_LINE_BOX: + + // Set the line position. Discard if ellipsis is enabled and the position exceeds the boundaries + // of the box. + 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 ) ) ) ) { - update = MultiLineLayout( layoutParameters, - glyphPositions, - lines, - actualSize ); + // 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 ) ); + + penY -= layout.ascender - lineRun.descender; + + ellipsisLayout.glyphIndex = lineRun.glyphIndex; + } + else + { + lineRun.glyphIndex = 0u; + ellipsisLayout.glyphIndex = 0u; + } + + 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 ); + + SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun.glyphIndex, + ellipsisLayout.numberOfGlyphs, + penY, + glyphPositions.Begin() + lineRun.glyphIndex ); + + if( 0u != numberOfLines ) + { + // Set the last line with the ellipsis layout. + *( lines.Begin() + ( numberOfLines - 1u ) ) = lineRun; + } + else + { + // Push the line. + lines.PushBack( lineRun ); + } + break; } - default: - 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; + } + + actualSize.height += ( lineRun.ascender + -lineRun.descender ); + + SetGlyphPositions( layoutParameters.glyphsBuffer + index, + layout.numberOfGlyphs, + penY, + glyphPositions.Begin() + index ); + + penY += -layout.descender; + + // Increase the glyph index. + index += layout.numberOfGlyphs; + } } - return update; + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--LayoutText\n\n" ); + + return true; } void ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters, @@ -371,6 +522,11 @@ struct LayoutEngine::Impl float penX = 0.f; + const CharacterIndex characterVisualIndex = bidiLine.characterRun.characterIndex + *bidiLine.visualToLogicalMap; + const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + *( layoutParameters.charactersToGlyphsBuffer + characterVisualIndex ) ); + + penX = -glyph.xBearing; + Vector2* glyphPositionsBuffer = glyphPositions.Begin(); // Traverses the characters of the right to left paragraph. @@ -401,195 +557,36 @@ struct LayoutEngine::Impl } } - void Align( const LayoutParameters& layoutParameters, - const Size& layoutSize, - const Vector& lines, - Vector& glyphPositions ) + void Align( const Size& layoutSize, + Vector& lines ) { - 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::ConstIterator it = lines.Begin(), endIt = lines.End(); + for( Vector::Iterator it = lines.Begin(), endIt = lines.End(); it != endIt; ++it ) { - const LineRun& line = *it; - - // 1) Get the paragrap's direction. - bool paragraphDirection = false; - - // Check if there is any right to left line. - if( ( NULL != layoutParameters.lineBidirectionalInfoRunsBuffer ) && - ( bidiLineIndex < layoutParameters.numberOfBidirectionalInfoRuns ) ) - { - 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; - } - } - - // 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 ) - { - Vector2& position = *( glyphPositionsBuffer + index ); - - position.x += alignOffset; - } + LineRun& line = *it; + const bool isLastLine = lines.End() == it + 1u; + + // Calculate the alignment offset accordingly with the align option, + // the box width, line length, and the paragraphs direction. + CalculateHorizontalAlignment( layoutSize.width, + line, + isLastLine ); } } - bool SingleLineLayout( const LayoutParameters& layoutParameters, - Vector& glyphPositions, - Vector& lines, - Size& actualSize ) + void CalculateHorizontalAlignment( float boxWidth, + LineRun& line, + bool isLastLine ) { - LineLayout layout; - layout.glyphIndex = 0u; - GetLineLayoutForBox( layoutParameters, - layout ); - - // Create a line run and add it to the lines. - const GlyphIndex lastGlyphIndex = layoutParameters.totalNumberOfGlyphs - 1u; - - LineRun lineRun; - lineRun.glyphIndex = 0u; - lineRun.numberOfGlyphs = layoutParameters.totalNumberOfGlyphs; - lineRun.characterRun.characterIndex = 0u; - lineRun.characterRun.numberOfCharacters = *( layoutParameters.glyphsToCharactersBuffer + lastGlyphIndex ) + *( layoutParameters.charactersPerGlyphBuffer + lastGlyphIndex ); - lineRun.width = layout.length; - lineRun.ascender = layout.ascender; - lineRun.descender = layout.descender; - lineRun.extraLength = layout.wsLengthEndOfLine; - lineRun.direction = false; - - lines.PushBack( lineRun ); - - // Update the actual size. - actualSize.width = layout.length; - actualSize.height = lineRun.ascender + -lineRun.descender; - - float penX = 0.f; - float penY = layout.ascender; - - Vector2* glyphPositionsBuffer = glyphPositions.Begin(); - for( GlyphIndex glyphIndex = 0u; glyphIndex < layout.numberOfGlyphs; ++glyphIndex ) - { - const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + glyphIndex ); - Vector2& position = *( glyphPositionsBuffer + glyphIndex ); - - position.x = penX + glyph.xBearing; - position.y = penY - glyph.yBearing; - - penX += glyph.advance; - } - - return true; - } - - bool MultiLineLayout( const LayoutParameters& layoutParameters, - Vector& glyphPositions, - Vector& lines, - Size& actualSize ) - { - float penY = 0.f; - for( GlyphIndex index = 0u; index < layoutParameters.totalNumberOfGlyphs; ) - { - float penX = 0.f; - - // Get the layout for the line. - LineLayout layout; - layout.glyphIndex = index; - GetMultiLineLayoutForBox( layoutParameters, - layout ); - - if( 0u == layout.numberOfGlyphs ) - { - // The width is too small and no characters are laid-out. - return false; - } - - // Create a line run and add it to the lines. - const GlyphIndex lastGlyphIndex = index + layout.numberOfGlyphs - 1u; - - 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.width = layout.length + ( ( layout.widthAdvanceDiff > 0.f ) ? layout.widthAdvanceDiff : 0.f ); - lineRun.ascender = layout.ascender; - lineRun.descender = layout.descender; - lineRun.extraLength = layout.wsLengthEndOfLine; - lineRun.direction = false; - - lines.PushBack( lineRun ); - - // Update the actual size. - if( layout.length + layout.widthAdvanceDiff > actualSize.width ) - { - actualSize.width = layout.length; - } - - actualSize.height += ( lineRun.ascender + -lineRun.descender ); - - // Traverse the glyphs and set the positions. - - penY += layout.ascender; - - Vector2* glyphPositionsBuffer = glyphPositions.Begin(); - for( GlyphIndex i = index; i < index + layout.numberOfGlyphs; ++i ) - { - const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + i ); - Vector2& position = *( glyphPositionsBuffer + i ); - - position.x = penX + glyph.xBearing; - position.y = penY - glyph.yBearing; - - penX += glyph.advance; - } - - penY += -layout.descender; - - // Increase the glyph index. - index += layout.numberOfGlyphs; - } - - return true; - } - - float CalculateHorizontalAlignment( float boxWidth, - float lineLength, - float extraLength, - bool paragraphDirection ) - { - float offset = 0.f; + line.alignmentOffset = 0.f; + const bool isRTL = RTL == line.direction; + float lineLength = line.width; HorizontalAlignment alignment = mHorizontalAlignment; - if( paragraphDirection && + if( isRTL && ( HORIZONTAL_ALIGN_CENTER != alignment ) ) { if( HORIZONTAL_ALIGN_BEGIN == alignment ) @@ -606,29 +603,25 @@ struct LayoutEngine::Impl { case HORIZONTAL_ALIGN_BEGIN: { - offset = 0.f; + line.alignmentOffset = 0.f; break; } case HORIZONTAL_ALIGN_CENTER: { - offset = 0.5f * ( boxWidth - lineLength ); - const int intOffset = static_cast( offset ); // try to avoid pixel alignment. - offset = static_cast( intOffset ); + line.alignmentOffset = floorf( 0.5f * ( boxWidth - lineLength ) ); // try to avoid pixel alignment. break; } case HORIZONTAL_ALIGN_END: { - offset = boxWidth - lineLength; + line.alignmentOffset = boxWidth - lineLength; break; } } - if( paragraphDirection ) + if( isRTL ) { - offset -= extraLength; + line.alignmentOffset -= line.extraLength; } - - return offset; } LayoutEngine::Layout mLayout; @@ -636,6 +629,8 @@ struct LayoutEngine::Impl LayoutEngine::VerticalAlignment mVerticalAlignment; TextAbstraction::FontClient mFontClient; + + bool mEllipsisEnabled:1; }; LayoutEngine::LayoutEngine() @@ -659,6 +654,16 @@ unsigned int LayoutEngine::GetLayout() const return mImpl->mLayout; } +void LayoutEngine::SetTextEllipsisEnabled( bool enabled ) +{ + mImpl->mEllipsisEnabled = enabled; +} + +bool LayoutEngine::GetTextEllipsisEnabled() const +{ + return mImpl->mEllipsisEnabled; +} + void LayoutEngine::SetHorizontalAlignment( HorizontalAlignment alignment ) { mImpl->mHorizontalAlignment = alignment; @@ -697,15 +702,11 @@ void LayoutEngine::ReLayoutRightToLeftLines( const LayoutParameters& layoutParam glyphPositions ); } -void LayoutEngine::Align( const LayoutParameters& layoutParameters, - const Size& layoutSize, - const Vector& lines, - Vector& glyphPositions ) +void LayoutEngine::Align( const Size& layoutSize, + Vector& lines ) { - mImpl->Align( layoutParameters, - layoutSize, - lines, - glyphPositions ); + mImpl->Align( layoutSize, + lines ); } } // namespace Text