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=442b631fcfffc2e54ab112a54c05e2baf22e9dcf;hb=e5a56dace042712c1d89015bcb43942dfb237af8;hpb=85b83b75993f7e01302d67c19aa53c3e1fc63586 diff --git a/dali-toolkit/internal/text/layouts/layout-engine.cpp b/dali-toolkit/internal/text/layouts/layout-engine.cpp index 442b631..9d81116 100644 --- a/dali-toolkit/internal/text/layouts/layout-engine.cpp +++ b/dali-toolkit/internal/text/layouts/layout-engine.cpp @@ -20,9 +20,8 @@ // EXTERNAL INCLUDES #include -#include -#include #include +#include // INTERNAL INCLUDES #include @@ -46,6 +45,27 @@ namespace 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 @@ -102,9 +122,9 @@ struct LayoutEngine::Impl : mLayout( LayoutEngine::SINGLE_LINE_BOX ), mHorizontalAlignment( LayoutEngine::HORIZONTAL_ALIGN_BEGIN ), mVerticalAlignment( LayoutEngine::VERTICAL_ALIGN_TOP ), + mCursorWidth( CURSOR_WIDTH ), mEllipsisEnabled( false ) { - mFontClient = TextAbstraction::FontClient::Get(); } /** @@ -116,7 +136,7 @@ struct LayoutEngine::Impl 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 ) @@ -172,7 +192,7 @@ struct LayoutEngine::Impl * @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 + * 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 @@ -211,7 +231,7 @@ struct LayoutEngine::Impl float tmpExtraBearing = ( 0.f > glyphInfo.xBearing ) ? -glyphInfo.xBearing : 0.f; - tmpLineLayout.length += 1.f; // Added one unit to give some space to the cursor. + tmpLineLayout.length += mCursorWidth; // Added to give some space to the cursor. // Calculate the line height if there is no characters. FontId lastFontId = glyphInfo.fontId; @@ -219,8 +239,9 @@ struct LayoutEngine::Impl bool oneWordLaidOut = false; + const GlyphIndex lastGlyphPlusOne = parameters.startGlyphIndex + parameters.numberOfGlyphs; for( GlyphIndex glyphIndex = lineLayout.glyphIndex; - glyphIndex < parameters.totalNumberOfGlyphs; + glyphIndex < lastGlyphPlusOne; ++glyphIndex ) { DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index : %d\n", glyphIndex ); @@ -369,7 +390,7 @@ struct LayoutEngine::Impl { 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; @@ -420,7 +441,7 @@ struct LayoutEngine::Impl ( TextAbstraction::WORD_BREAK == wordBreakInfo ) ) { oneWordLaidOut = true; - DALI_LOG_INFO( gLogFilter, Debug::Verbose, " One word laid out\n" ); + 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. @@ -438,6 +459,34 @@ struct LayoutEngine::Impl 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, @@ -451,7 +500,6 @@ struct LayoutEngine::Impl const GlyphInfo& glyph = *glyphsBuffer; float penX = ( 0.f > glyph.xBearing ) ? -glyph.xBearing : 0.f; - penX += 1.f; // Added one unit to give some space to the cursor. for( GlyphIndex i = 0u; i < numberOfGlyphs; ++i ) { @@ -465,19 +513,327 @@ struct LayoutEngine::Impl } } + /** + * @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& actualSize ) + 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; - float penY = 0.f; - for( GlyphIndex index = 0u; index < layoutParameters.totalNumberOfGlyphs; ) + // 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; + + // 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; @@ -499,6 +855,8 @@ struct LayoutEngine::Impl { // 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; } @@ -507,171 +865,159 @@ struct LayoutEngine::Impl 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.extraBearing + layout.length + layout.extraWidth > 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 ) ); - - penY -= layout.ascender - lineRun.descender; - - ellipsisLayout.glyphIndex = lineRun.glyphIndex; - } - else - { - lineRun.glyphIndex = 0u; - ellipsisLayout.glyphIndex = 0u; - } - - GetLineLayoutForBox( layoutParameters, - ellipsisLayout, - currentParagraphDirection, - true ); - - lineRun.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.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 ); - } + 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; - LineRun lineRun; - lineRun.glyphIndex = index; - lineRun.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 + if( numberOfLines == linesCapacity ) { - lineRun.width = layout.extraBearing + layout.length + layout.extraWidth; - lineRun.extraLength = ( layout.wsLengthEndOfLine > 0.f ) ? layout.wsLengthEndOfLine - layout.extraWidth : 0.f; + // Reserve more space for the next lines. + linesBuffer = ResizeLinesBuffer( lines, + newLines, + linesCapacity, + updateCurrentBuffer ); } - lineRun.ascender = layout.ascender; - lineRun.descender = layout.descender; - lineRun.direction = false; - lineRun.ellipsis = false; - lines.PushBack( lineRun ); + // Updates the current text's layout with the line's layout. + UpdateTextLayout( layoutParameters, + layout, + layoutSize, + linesBuffer, + index, + numberOfLines, + isLastLine ); - // Update the actual size. - if( lineRun.width > actualSize.width ) + if( isLastLine && + layoutParameters.isLastNewParagraph && + ( mLayout == MULTI_LINE_BOX ) ) { - actualSize.width = lineRun.width; - } + // The last character of the text is a new paragraph character. + // An extra line with no characters is added to increase the text's height + // in order to place the cursor. + + if( numberOfLines == linesCapacity ) + { + // Reserve more space for the next lines. + linesBuffer = ResizeLinesBuffer( lines, + newLines, + linesCapacity, + updateCurrentBuffer ); + } - actualSize.height += ( lineRun.ascender + -lineRun.descender ); + UpdateTextLayout( layoutParameters, + layout, + layoutSize, + linesBuffer, + index, + numberOfLines ); + } // whether to add a last line. + // Sets the positions of the glyphs. SetGlyphPositions( layoutParameters.glyphsBuffer + index, layout.numberOfGlyphs, penY, - glyphPositions.Begin() + index ); + glyphPositionsBuffer + index - layoutParameters.startGlyphIndex ); + // Updates the vertical pen's position. penY += -layout.descender; // Increase the glyph index. index += layout.numberOfGlyphs; - if( isLastLine && - layoutParameters.isLastNewParagraph && - ( mLayout == MULTI_LINE_BOX ) ) - { - // Need to add a new line with no characters but with height to increase the actualSize.height - const GlyphInfo& glyphInfo = *( layoutParameters.glyphsBuffer + layoutParameters.totalNumberOfGlyphs - 1u ); - - Text::FontMetrics fontMetrics; - mFontClient.GetFontMetrics( glyphInfo.fontId, fontMetrics ); - - LineRun lineRun; - lineRun.glyphIndex = 0u; - lineRun.numberOfGlyphs = 0u; - lineRun.characterRun.characterIndex = 0u; - 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; - - actualSize.height += ( lineRun.ascender + -lineRun.descender ); - - lines.PushBack( lineRun ); - } - } + } // no ellipsis } // end for() traversing glyphs. + if( updateCurrentBuffer ) + { + glyphPositions.Insert( glyphPositions.Begin() + layoutParameters.startGlyphIndex, + newGlyphPositions.Begin(), + newGlyphPositions.End() ); + + 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, + CharacterIndex startIndex, + Length numberOfCharacters, Vector& 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; - penX += 1.f; // Added one unit to give some space to the cursor. Vector2* glyphPositionsBuffer = glyphPositions.Begin(); @@ -703,48 +1049,71 @@ struct LayoutEngine::Impl } } - void Align( const Size& layoutSize, + void Align( const Size& size, + CharacterIndex startIndex, + Length numberOfCharacters, Vector& lines ) { - // Traverse all lines and align the glyphs. + const CharacterIndex lastCharacterPlusOne = startIndex + numberOfCharacters; + // Traverse all lines and align the glyphs. for( Vector::Iterator it = lines.Begin(), endIt = lines.End(); it != endIt; ++it ) { 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 ); + if( line.characterRun.characterIndex < startIndex ) + { + // Do not align lines which have already been aligned. + continue; + } + + if( line.characterRun.characterIndex >= lastCharacterPlusOne ) + { + // 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, + line ); } } void CalculateHorizontalAlignment( float boxWidth, - LineRun& line, - bool isLastLine ) + LineRun& line ) { line.alignmentOffset = 0.f; const bool isRTL = RTL == line.direction; float lineLength = line.width; HorizontalAlignment alignment = mHorizontalAlignment; - if( isRTL && - ( HORIZONTAL_ALIGN_CENTER != alignment ) ) + if( isRTL ) { - if( HORIZONTAL_ALIGN_BEGIN == alignment ) + // Swap the alignment type if the line is right to left. + switch( alignment ) { - alignment = HORIZONTAL_ALIGN_END; - } - else - { - alignment = HORIZONTAL_ALIGN_BEGIN; + 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: @@ -755,37 +1124,16 @@ struct LayoutEngine::Impl { // 'Remove' the white spaces at the end of the line (which are at the beginning in visual order) line.alignmentOffset -= line.extraLength; - - if( isLastLine ) - { - line.alignmentOffset += std::min( line.extraLength, boxWidth - lineLength ); - } } break; } case HORIZONTAL_ALIGN_CENTER: { - if( isLastLine && !isRTL ) - { - lineLength += line.extraLength; - if( lineLength > boxWidth ) - { - lineLength = boxWidth; - line.alignmentOffset = 0.f; - break; - } - } - line.alignmentOffset = 0.5f * ( boxWidth - lineLength ); if( isRTL ) { line.alignmentOffset -= line.extraLength; - - if( isLastLine ) - { - line.alignmentOffset += 0.5f * std::min( line.extraLength, boxWidth - lineLength ); - } } line.alignmentOffset = floorf( line.alignmentOffset ); // try to avoid pixel alignment. @@ -793,16 +1141,6 @@ struct LayoutEngine::Impl } case HORIZONTAL_ALIGN_END: { - if( isLastLine && !isRTL ) - { - lineLength += line.extraLength; - if( lineLength > boxWidth ) - { - line.alignmentOffset = 0.f; - break; - } - } - if( isRTL ) { lineLength += line.extraLength; @@ -817,8 +1155,9 @@ struct LayoutEngine::Impl LayoutEngine::Layout mLayout; LayoutEngine::HorizontalAlignment mHorizontalAlignment; LayoutEngine::VerticalAlignment mVerticalAlignment; + float mCursorWidth; - TextAbstraction::FontClient mFontClient; + IntrusivePtr mMetrics; bool mEllipsisEnabled:1; }; @@ -834,12 +1173,17 @@ 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; } @@ -874,28 +1218,46 @@ 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& actualSize ) + Size& layoutSize ) { return mImpl->LayoutText( layoutParameters, glyphPositions, lines, - actualSize ); + layoutSize ); } void LayoutEngine::ReLayoutRightToLeftLines( const LayoutParameters& layoutParameters, + CharacterIndex startIndex, + Length numberOfCharacters, Vector& glyphPositions ) { mImpl->ReLayoutRightToLeftLines( layoutParameters, + startIndex, + numberOfCharacters, glyphPositions ); } -void LayoutEngine::Align( const Size& layoutSize, +void LayoutEngine::Align( const Size& size, + CharacterIndex startIndex, + Length numberOfCharacters, Vector& lines ) { - mImpl->Align( layoutSize, + mImpl->Align( size, + startIndex, + numberOfCharacters, lines ); }