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=9d81116cbbbe6e3c699e1a0ef09d8b6c5b80102d;hp=ac2c53ff85a60df602f605e819a08430bf1c85dd;hb=e5a56dace042712c1d89015bcb43942dfb237af8;hpb=830f03638ec6ecd3b12ba3d9eb6419fdb3a3db09 diff --git a/dali-toolkit/internal/text/layouts/layout-engine.cpp b/dali-toolkit/internal/text/layouts/layout-engine.cpp index ac2c53f..9d81116 100644 --- a/dali-toolkit/internal/text/layouts/layout-engine.cpp +++ b/dali-toolkit/internal/text/layouts/layout-engine.cpp @@ -19,12 +19,13 @@ #include // EXTERNAL INCLUDES -#include -#include +#include +#include +#include // INTERNAL INCLUDES -#include -#include +#include +#include namespace Dali { @@ -35,179 +36,1130 @@ namespace Toolkit 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; +const float CURSOR_WIDTH = 1.f; + +Length CountParagraphs( const LayoutParameters& layoutParameters ) +{ + Length numberOfParagraphs = 0u; + + const CharacterIndex startCharacterIndex = *( layoutParameters.glyphsToCharactersBuffer + layoutParameters.startGlyphIndex ); + + const GlyphIndex lastGlyphIndex = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs - 1u; + const CharacterIndex lastCharacterIndexPlusOne = *( layoutParameters.glyphsToCharactersBuffer + lastGlyphIndex ) + *( layoutParameters.charactersPerGlyphBuffer + lastGlyphIndex ); + + for( CharacterIndex index = startCharacterIndex; index < lastCharacterIndexPlusOne; ++index ) + { + if( TextAbstraction::LINE_MUST_BREAK == *( layoutParameters.lineBreakInfoBuffer + index ) ) + { + ++numberOfParagraphs; + } + } + + return numberOfParagraphs; +} + +} //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 numberOfGlyphs; ///< The number of glyph 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 ascender; ///< The maximum ascender of all fonts in the line. + float descender; ///< The minimum descender of all fonts in the line. +}; + struct LayoutEngine::Impl { Impl() - : mLayout( LayoutEngine::SINGLE_LINE_BOX ) + : mLayout( LayoutEngine::SINGLE_LINE_BOX ), + mHorizontalAlignment( LayoutEngine::HORIZONTAL_ALIGN_BEGIN ), + mVerticalAlignment( LayoutEngine::VERTICAL_ALIGN_TOP ), + mCursorWidth( CURSOR_WIDTH ), + mEllipsisEnabled( false ) { - mFontClient = TextAbstraction::FontClient::Get(); } - void UpdateVisualModel( const Vector2& boundingBox, - const Vector& glyphs, - const Vector& characterIndices, - const Vector& charactersPerGlyph, - VisualModel& visualModel ) + /** + * @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 UpdateLineHeight( FontId fontId, LineLayout& lineLayout ) { - // TODO Switch between different layouts + Text::FontMetrics fontMetrics; + mMetrics->GetFontMetrics( fontId, fontMetrics ); - visualModel.SetGlyphs( &glyphs[0], - &characterIndices[0], - &charactersPerGlyph[0], - glyphs.Count() ); + // Sets the maximum ascender. + if( fontMetrics.ascender > lineLayout.ascender ) + { + lineLayout.ascender = fontMetrics.ascender; + } - UpdateGlyphPositions( boundingBox, visualModel ); + // Sets the minimum descender. + if( fontMetrics.descender < lineLayout.descender ) + { + lineLayout.descender = fontMetrics.descender; + } } - void UpdateGlyphPositions( const Vector2& boundingBox, VisualModel& visualModel ) + /** + * @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 ) { - if( LayoutEngine::SINGLE_LINE_BOX == mLayout ) + lineLayout.numberOfCharacters += tmpLineLayout.numberOfCharacters; + lineLayout.numberOfGlyphs += tmpLineLayout.numberOfGlyphs; + lineLayout.length += tmpLineLayout.length; + + if( 0.f < tmpLineLayout.length ) { - SingleLineLayout( boundingBox, visualModel ); + lineLayout.length += lineLayout.wsLengthEndOfLine; + + lineLayout.wsLengthEndOfLine = tmpLineLayout.wsLengthEndOfLine; } else { - MultiLineLayout( boundingBox, visualModel ); + lineLayout.wsLengthEndOfLine += tmpLineLayout.wsLengthEndOfLine; + } + + if( tmpLineLayout.ascender > lineLayout.ascender ) + { + lineLayout.ascender = tmpLineLayout.ascender; + } + + if( tmpLineLayout.descender < lineLayout.descender ) + { + lineLayout.descender = tmpLineLayout.descender; } } - // TODO - Rewrite this to handle bidi - void SingleLineLayout( const Vector2& boundingBox, VisualModel& visualModel ) + /** + * 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, + LineLayout& lineLayout, + CharacterDirection& paragraphDirection, + bool completelyFill ) { - Length glyphCount = visualModel.GetNumberOfGlyphs(); + 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; - std::vector glyphPositions; - glyphPositions.reserve( glyphCount ); + const bool isMultiline = mLayout == MULTI_LINE_BOX; + const GlyphIndex lastGlyphIndex = parameters.totalNumberOfGlyphs - 1u; - if( glyphCount > 0 ) - { - // FIXME Single font assumption - Text::FontMetrics fontMetrics; - GlyphInfo firstGlyph; - visualModel.GetGlyphs( &firstGlyph, 0, 1 ); - mFontClient.GetFontMetrics( firstGlyph.fontId, fontMetrics ); + // 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. + const GlyphInfo& glyphInfo = *( parameters.glyphsBuffer + lineLayout.glyphIndex ); - float penX( 0 ); - float penY( fontMetrics.ascender ); // Move to baseline + // 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; - for( unsigned int i=0; i glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f; + + tmpLineLayout.length += mCursorWidth; // Added to give some space to the cursor. - glyphPositions.push_back( Vector2( penX + glyph.xBearing, - penY - glyph.yBearing ) ); + // Calculate the line height if there is no characters. + FontId lastFontId = glyphInfo.fontId; + UpdateLineHeight( lastFontId, tmpLineLayout ); - penX += glyph.advance; + bool oneWordLaidOut = false; + + const GlyphIndex lastGlyphPlusOne = parameters.startGlyphIndex + parameters.numberOfGlyphs; + for( GlyphIndex glyphIndex = lineLayout.glyphIndex; + glyphIndex < lastGlyphPlusOne; + ++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 ); + + // 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; } - visualModel.SetGlyphPositions( &glyphPositions[0], glyphCount ); + // 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 CharacterIndex characterFirstIndex = *( parameters.glyphsToCharactersBuffer + glyphIndex ); + const CharacterIndex characterLastIndex = characterFirstIndex + ( ( 1u > charactersPerGlyph ) ? 0u : charactersPerGlyph - 1u ); - visualModel.SetActualSize( Vector2(penX, fontMetrics.height) ); - } - } + // Get the line break info for the current character. + const LineBreakInfo lineBreakInfo = *( parameters.lineBreakInfoBuffer + characterLastIndex ); - // TODO - Rewrite this to handle bidi - void MultiLineLayout( const Vector2& boundingBox, VisualModel& visualModel ) - { - Length glyphCount = visualModel.GetNumberOfGlyphs(); + // Get the word break info for the current character. + const WordBreakInfo wordBreakInfo = *( parameters.wordBreakInfoBuffer + characterLastIndex ); - std::vector glyphPositions; - glyphPositions.reserve( glyphCount ); + // Increase the number of characters. + tmpLineLayout.numberOfCharacters += charactersPerGlyph; - if( glyphCount > 0 ) - { - Size actualSize; + // Increase the number of glyphs. + tmpLineLayout.numberOfGlyphs++; + + // Check whether is a white space. + const Character character = *( parameters.textBuffer + characterFirstIndex ); + const bool isWhiteSpace = TextAbstraction::IsWhiteSpace( character ); - // FIXME Single font assumption - Text::FontMetrics fontMetrics; - GlyphInfo firstGlyph; - visualModel.GetGlyphs( &firstGlyph, 0, 1 ); - mFontClient.GetFontMetrics( firstGlyph.fontId, fontMetrics ); + // 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; - float penX( 0 ); - float penY( fontMetrics.ascender ); // Move to baseline + // Get the character's direction. + const CharacterDirection characterDirection = ( NULL == parameters.characterDirectionBuffer ) ? false : *( parameters.characterDirectionBuffer + characterFirstIndex ); - unsigned int i=0; - while( i < glyphCount ) + // Increase the accumulated length. + if( isWhiteSpace ) { - // Skip initial whitespace - for( ; i 0 && - glyph.height > 0 ) + // 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 ) { - break; + // <-- + // | Rrrrr| + // or + // | Rllrrr| + // or + // |lllrrrrr| + // | Rll| + // + + tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f; } - else + else // LTR { - glyphPositions.push_back( Vector2( penX + glyph.xBearing, - penY - glyph.yBearing ) ); + // --> + // |lllL | + // or + // |llrrL | + // or + // |lllllrrr| + // |rrL | + // + + const float extraWidth = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance; + tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f; } } - - // Find last glyph for the next line - unsigned int endIndex = i; - float endPenX = penX; - unsigned int j=i; - for( ; j + // |lllR | - endPenX += glyph.advance; + const float extraWidth = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance; + tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f; + } + else // LTR + { + // <-- + // | Lrrrr| - if( glyph.width <= 0 || - glyph.height <= 0 ) + tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f; + } + } + else if( characterDirection == firstCharacterDirection ) { - // Potential line end found - endIndex = j; + if( RTL == characterDirection ) + { + // --> + // |llllllrr| + // |Rr | + + tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f; + } + else // LTR + { + // <-- + // |llllrrrr| + // | llL| + + const float extraWidth = glyphInfo.xBearing + glyphInfo.width - glyphInfo.advance; + tmpExtraWidth = ( 0.f < extraWidth ) ? extraWidth : 0.f; + } } - else if( endPenX > boundingBox.width ) + } + + // 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( ( 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 ) { - break; + tmpLineLayout.numberOfCharacters -= charactersPerGlyph; + --tmpLineLayout.numberOfGlyphs; + 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" ); } - actualSize.width = ( actualSize.width < endPenX ) ? endPenX : actualSize.width; + lineLayout.extraBearing = tmpExtraBearing; + lineLayout.extraWidth = tmpExtraWidth; + + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox.\n" ); + + return; + } + + if( ( isMultiline || isLastGlyph ) && + ( TextAbstraction::LINE_MUST_BREAK == lineBreakInfo ) ) + { + // 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 ) ) + { + 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. + MergeLineLayout( lineLayout, tmpLineLayout ); + + tmpLineLayout.Clear(); + } + + previousCharacterDirection = characterDirection; + } + + lineLayout.extraBearing = tmpExtraBearing; + lineLayout.extraWidth = tmpExtraWidth; + + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" ); + } + + /** + * @brief Calculates the vertical offset to add to the new laid-out glyphs. + * + * @pre @p lineIndex must be between 0 and the number of lines (both inclusive). + * + * @param[in] lines The previously laid-out lines. + * @param[in] lineIndex Index to the line where the new laid-out lines are inserted. + * + * @return The vertical offset of the lines starting from the beginning to the line @p lineIndex. + */ + float SetParagraphOffset( const Vector& lines, + LineIndex lineIndex ) + { + float offset = 0.f; + + for( Vector::ConstIterator it = lines.Begin(), + endIt = lines.Begin() + lineIndex; + it != endIt; + ++it ) + { + const LineRun& line = *it; + + offset += line.ascender + -line.descender; + } + + return offset; + } + + void SetGlyphPositions( const GlyphInfo* const glyphsBuffer, + Length numberOfGlyphs, + float penY, + 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. + + const GlyphInfo& glyph = *glyphsBuffer; + float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing : 0.f; + + 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; + } + } + + /** + * @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& lines, + Vector& 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 LayoutParameters& layoutParameters, + const LineLayout& layout, + Size& layoutSize, + LineRun* linesBuffer, + Vector2* glyphPositionsBuffer, + Length& numberOfLines, + float penY, + CharacterDirection currentParagraphDirection ) + { + const bool ellipsis = ( ( penY - layout.descender > layoutParameters.boundingBox.height ) || + ( ( mLayout == SINGLE_LINE_BOX ) && + ( layout.extraBearing + layout.length + layout.extraWidth > layoutParameters.boundingBox.width ) ) ); + + if( ellipsis ) + { + // 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; + + 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; + layoutSize.height += ( lineRun->ascender + -lineRun->descender ); + + SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun->glyphRun.glyphIndex, + ellipsisLayout.numberOfGlyphs, + penY, + 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 LayoutParameters& 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; + 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 ); + } + + /** + * @brief Updates the text layout with the last 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. + */ + void UpdateTextLayout( const LayoutParameters& layoutParameters, + const LineLayout& layout, + Size& layoutSize, + LineRun* linesBuffer, + GlyphIndex index, + 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 = index + layout.numberOfGlyphs; + lineRun.glyphRun.numberOfGlyphs = 0u; + lineRun.characterRun.characterIndex = layout.characterIndex + layout.numberOfCharacters; + 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 ); + } + + /** + * @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& lines, + Size& layoutSize ) + { + for( Vector::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 ); + } + } + + /** + * @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 LayoutParameters& layoutParameters, + Vector& lines, + Length characterOffset, + Length glyphOffset ) + { + // Update the glyph and character runs. + for( Vector::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 LayoutParameters& layoutParameters, + Vector& glyphPositions, + Vector& lines, + Size& layoutSize ) + { + 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( 0u == layoutParameters.numberOfGlyphs ) + { + // Nothing to do if there are no glyphs to layout. + return false; + } + + // 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 newGlyphPositions; + + LineRun* linesBuffer = NULL; + Vector newLines; - // If end of text or no whitespace found - if( glyphCount == j || - endIndex == i ) + // Estimate the number of lines. + // TODO: In a next patch the paragraphs are properly managed and this can be removed. + Length linesCapacity = CountParagraphs( layoutParameters ); + 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 = SetParagraphOffset( lines, + layoutParameters.startLineIndex ); + + const GlyphIndex lastGlyphPlusOne = layoutParameters.startGlyphIndex + layoutParameters.numberOfGlyphs; + 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 ); + 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; + } + + // 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 ); + + bool ellipsis = false; + if( mEllipsisEnabled ) + { + // Does the ellipsis of the last line. + ellipsis = EllipsisLine( layoutParameters, + layout, + layoutSize, + linesBuffer, + glyphPositionsBuffer, + numberOfLines, + penY, + currentParagraphDirection ); + } + + 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; + + if( numberOfLines == linesCapacity ) { - endIndex = j; + // Reserve more space for the next lines. + linesBuffer = ResizeLinesBuffer( lines, + newLines, + linesCapacity, + updateCurrentBuffer ); } - for( ; i& 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 ); + + 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 ) ); + + float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing : 0.f; + + 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 ) { - GlyphInfo glyph; - visualModel.GetGlyphs( &glyph, i, 1 ); + // 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 ); - glyphPositions.push_back( Vector2( penX + glyph.xBearing, - penY - glyph.yBearing ) ); + const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + glyphIndex ); + Vector2& position = *( glyphPositionsBuffer + glyphIndex ); + position.x = penX + glyph.xBearing; penX += glyph.advance; } + } + } + } + + void Align( const Size& size, + CharacterIndex startIndex, + Length numberOfCharacters, + Vector& lines ) + { + const CharacterIndex lastCharacterPlusOne = startIndex + numberOfCharacters; - // Go to next line - penX = 0; - penY += fontMetrics.height; + // Traverse all lines and align the glyphs. + for( Vector::Iterator it = lines.Begin(), endIt = lines.End(); + it != endIt; + ++it ) + { + LineRun& line = *it; - actualSize.height += fontMetrics.height; + if( line.characterRun.characterIndex < startIndex ) + { + // Do not align lines which have already been aligned. + continue; } - visualModel.SetGlyphPositions( &glyphPositions[0], glyphCount ); + if( line.characterRun.characterIndex >= lastCharacterPlusOne ) + { + // Do not align lines beyond the last laid-out character. + break; + } - visualModel.SetActualSize( actualSize ); + // Calculate the line's alignment offset accordingly with the align option, + // the box width, line length, and the paragraph's direction. + CalculateHorizontalAlignment( size.width, + line ); } } - unsigned int mLayout; + void CalculateHorizontalAlignment( float boxWidth, + LineRun& line ) + { + line.alignmentOffset = 0.f; + const bool isRTL = RTL == line.direction; + float lineLength = line.width; - TextAbstraction::FontClient mFontClient; + HorizontalAlignment alignment = mHorizontalAlignment; + if( isRTL ) + { + // Swap the alignment type if the line is right to left. + switch( alignment ) + { + case HORIZONTAL_ALIGN_BEGIN: + { + alignment = HORIZONTAL_ALIGN_END; + break; + } + case HORIZONTAL_ALIGN_CENTER: + { + // Nothing to do. + break; + } + case HORIZONTAL_ALIGN_END: + { + alignment = HORIZONTAL_ALIGN_BEGIN; + break; + } + } + } + + // Calculate the horizontal line offset. + switch( alignment ) + { + case HORIZONTAL_ALIGN_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 HORIZONTAL_ALIGN_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 HORIZONTAL_ALIGN_END: + { + if( isRTL ) + { + lineLength += line.extraLength; + } + + line.alignmentOffset = boxWidth - lineLength; + break; + } + } + } + + LayoutEngine::Layout mLayout; + LayoutEngine::HorizontalAlignment mHorizontalAlignment; + LayoutEngine::VerticalAlignment mVerticalAlignment; + float mCursorWidth; + + IntrusivePtr mMetrics; + + bool mEllipsisEnabled:1; }; LayoutEngine::LayoutEngine() @@ -221,27 +1173,92 @@ LayoutEngine::~LayoutEngine() delete mImpl; } +void LayoutEngine::SetMetrics( MetricsPtr& metrics ) +{ + mImpl->mMetrics = metrics; +} + void LayoutEngine::SetLayout( Layout layout ) { mImpl->mLayout = layout; } -unsigned int LayoutEngine::GetLayout() const +LayoutEngine::Layout LayoutEngine::GetLayout() const { return mImpl->mLayout; } -void LayoutEngine::UpdateVisualModel( const Vector2& boundingBox, - const Vector& glyphs, - const Vector& characterIndices, - const Vector& charactersPerGlyph, - VisualModel& visualModel ) +void LayoutEngine::SetTextEllipsisEnabled( bool enabled ) +{ + mImpl->mEllipsisEnabled = enabled; +} + +bool LayoutEngine::GetTextEllipsisEnabled() const +{ + return mImpl->mEllipsisEnabled; +} + +void LayoutEngine::SetHorizontalAlignment( HorizontalAlignment alignment ) +{ + mImpl->mHorizontalAlignment = alignment; +} + +LayoutEngine::HorizontalAlignment LayoutEngine::GetHorizontalAlignment() const +{ + return mImpl->mHorizontalAlignment; +} + +void LayoutEngine::SetVerticalAlignment( VerticalAlignment alignment ) +{ + mImpl->mVerticalAlignment = alignment; +} + +LayoutEngine::VerticalAlignment LayoutEngine::GetVerticalAlignment() const +{ + return mImpl->mVerticalAlignment; +} + +void LayoutEngine::SetCursorWidth( int width ) +{ + mImpl->mCursorWidth = static_cast( width ); +} + +int LayoutEngine::GetCursorWidth() const +{ + return static_cast( mImpl->mCursorWidth ); +} + +bool LayoutEngine::LayoutText( const LayoutParameters& layoutParameters, + Vector& glyphPositions, + Vector& lines, + Size& layoutSize ) +{ + return mImpl->LayoutText( layoutParameters, + glyphPositions, + lines, + layoutSize ); +} + +void LayoutEngine::ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters, + CharacterIndex startIndex, + Length numberOfCharacters, + Vector& glyphPositions ) +{ + mImpl->ReLayoutRightToLeftLines( layoutParameters, + startIndex, + numberOfCharacters, + glyphPositions ); +} + +void LayoutEngine::Align( const Size& size, + CharacterIndex startIndex, + Length numberOfCharacters, + Vector& lines ) { - mImpl->UpdateVisualModel( boundingBox, - glyphs, - characterIndices, - charactersPerGlyph, - visualModel ); + mImpl->Align( size, + startIndex, + numberOfCharacters, + lines ); } } // namespace Text