X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Flayouts%2Flayout-engine.cpp;h=b018ed159081655e936b27edd5ab073500d51908;hb=5064025f6246c31c82cd1531084b639ac9c3237d;hp=e16510393cb423663346490a2ea5d4fb587e3c07;hpb=935e800159c04fa5d389628add6183eb68f778ee;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/text/layouts/layout-engine.cpp b/dali-toolkit/internal/text/layouts/layout-engine.cpp index e165103..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,6 +40,10 @@ 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; @@ -52,8 +57,8 @@ struct LineLayout LineLayout() : glyphIndex( 0u ), characterIndex( 0u ), - numberOfCharacters( 0u ), numberOfGlyphs( 0u ), + numberOfCharacters( 0u ), length( 0.f ), widthAdvanceDiff( 0.f ), wsLengthEndOfLine( 0.f ), @@ -68,8 +73,8 @@ struct LineLayout { glyphIndex = 0u; characterIndex = 0u; - numberOfCharacters = 0u; numberOfGlyphs = 0u; + numberOfCharacters = 0u; length = 0.f; widthAdvanceDiff = 0.f; wsLengthEndOfLine = 0.f; @@ -79,8 +84,8 @@ struct LineLayout 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 xBearing + width and the advance of the last glyph. float wsLengthEndOfLine; ///< The length of the white spaces at the end of the line. @@ -93,7 +98,8 @@ 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(); } @@ -160,10 +166,17 @@ struct LayoutEngine::Impl /** * 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 GetLineLayoutForBox( const LayoutParameters& parameters, - LineLayout& lineLayout ) + LineLayout& lineLayout, + bool completelyFill ) { + 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; @@ -209,6 +222,7 @@ struct LayoutEngine::Impl glyphIndex < parameters.totalNumberOfGlyphs; ++glyphIndex ) { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, " glyph index : %d\n", glyphIndex ); const bool isLastGlyph = glyphIndex == lastGlyphIndex; // Get the glyph info. @@ -237,6 +251,10 @@ 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 ) { @@ -261,10 +279,31 @@ struct LayoutEngine::Impl } // Check if the accumulated length fits in the width of the box. - if( isMultiline && oneWordLaidOut && !isWhiteSpace && + if( ( completelyFill || isMultiline ) && !isWhiteSpace && ( lineLayout.length + lineLayout.wsLengthEndOfLine + tmpLineLayout.length + tmpLineLayout.widthAdvanceDiff > boundingBoxWidth ) ) { // Current word does not fit in the box's width. + if( !oneWordLaidOut || completelyFill ) + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Break the word by character\n" ); + + // The word's with doesn't fit in the control's with. It needs to be split by character. + 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 + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Current word does not fit.\n" ); + } + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" ); return; } @@ -274,16 +313,16 @@ struct LayoutEngine::Impl // Must break the line. Update the line layout and return. MergeLineLayout( lineLayout, tmpLineLayout ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, " Must break\n" ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" ); return; } if( isMultiline && ( TextAbstraction::WORD_BREAK == wordBreakInfo ) ) { - if( !oneWordLaidOut && !isWhiteSpace ) - { - oneWordLaidOut = true; - } + 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. @@ -300,6 +339,37 @@ struct LayoutEngine::Impl lastFontId = glyphInfo.fontId; } } + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--GetLineLayoutForBox\n" ); + } + + 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. + float penX = 0.f; + + 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; + } } bool LayoutText( const LayoutParameters& layoutParameters, @@ -307,7 +377,8 @@ struct LayoutEngine::Impl Vector& lines, Size& actualSize ) { - Vector2* glyphPositionsBuffer = glyphPositions.Begin(); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->LayoutText\n" ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, " box size %f, %f\n", layoutParameters.boundingBox.width, layoutParameters.boundingBox.height ); float penY = 0.f; for( GlyphIndex index = 0u; index < layoutParameters.totalNumberOfGlyphs; ) @@ -316,67 +387,128 @@ struct LayoutEngine::Impl LineLayout layout; layout.glyphIndex = index; GetLineLayoutForBox( layoutParameters, - layout ); + 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 ) { // 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; } - 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; - - lines.PushBack( lineRun ); - - // Update the actual size. - if( lineRun.width > actualSize.width ) + // 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 ) ) ) ) { - actualSize.width = lineRun.width; - } + // Do not layout more lines if ellipsis is enabled. - actualSize.height += ( lineRun.ascender + -lineRun.descender ); + // The last line needs to be completely filled with characters. + // Part of a word may be used. - // Traverse the glyphs and set the positions. + const Length numberOfLines = lines.Count(); - penY += layout.ascender; + 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 ) ); - // 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; + penY -= layout.ascender - lineRun.descender; - const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + index ); - if( 0.f > glyph.xBearing ) - { - penX = -glyph.xBearing; - } + ellipsisLayout.glyphIndex = lineRun.glyphIndex; + } + else + { + lineRun.glyphIndex = 0u; + ellipsisLayout.glyphIndex = 0u; + } - for( GlyphIndex i = index; i < index + layout.numberOfGlyphs; ++i ) - { - const GlyphInfo& glyph = *( layoutParameters.glyphsBuffer + i ); - Vector2& position = *( glyphPositionsBuffer + i ); + 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 ); - position.x = penX + glyph.xBearing; - position.y = penY - glyph.yBearing; + SetGlyphPositions( layoutParameters.glyphsBuffer + lineRun.glyphIndex, + ellipsisLayout.numberOfGlyphs, + penY, + glyphPositions.Begin() + lineRun.glyphIndex ); - penX += glyph.advance; + if( 0u != numberOfLines ) + { + // Set the last line with the ellipsis layout. + *( lines.Begin() + ( numberOfLines - 1u ) ) = lineRun; + } + else + { + // Push the line. + lines.PushBack( lineRun ); + } + + 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; + penY += -layout.descender; - // Increase the glyph index. - index += layout.numberOfGlyphs; + // Increase the glyph index. + index += layout.numberOfGlyphs; + } } + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--LayoutText\n\n" ); + return true; } @@ -425,76 +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 ); } } - float CalculateHorizontalAlignment( float boxWidth, - float lineLength, - float extraLength, - bool paragraphDirection ) + void CalculateHorizontalAlignment( float boxWidth, + LineRun& line, + bool isLastLine ) { - 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 ) @@ -511,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; @@ -541,6 +629,8 @@ struct LayoutEngine::Impl LayoutEngine::VerticalAlignment mVerticalAlignment; TextAbstraction::FontClient mFontClient; + + bool mEllipsisEnabled:1; }; LayoutEngine::LayoutEngine() @@ -564,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; @@ -602,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