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=15894466122cb537cd08c212e3febd59d28ffdec;hb=5064025f6246c31c82cd1531084b639ac9c3237d;hpb=c62063a98f6870f4ba10ef6945a9ced75eeced0e diff --git a/dali-toolkit/internal/text/layouts/layout-engine.cpp b/dali-toolkit/internal/text/layouts/layout-engine.cpp index 1589446..b018ed1 100644 --- a/dali-toolkit/internal/text/layouts/layout-engine.cpp +++ b/dali-toolkit/internal/text/layouts/layout-engine.cpp @@ -21,7 +21,7 @@ // EXTERNAL INCLUDES #include #include -#include +#include #include // INTERNAL INCLUDES @@ -98,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(); } @@ -165,9 +166,14 @@ 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 ); @@ -273,16 +279,16 @@ struct LayoutEngine::Impl } // Check if the accumulated length fits in the width of the box. - if( isMultiline && !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 ) + 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 > 1u ) + if( tmpLineLayout.numberOfGlyphs > 0u ) { tmpLineLayout.numberOfCharacters -= charactersPerGlyph; --tmpLineLayout.numberOfGlyphs; @@ -336,13 +342,43 @@ struct LayoutEngine::Impl 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, Vector& glyphPositions, Vector& lines, Size& actualSize ) { DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->LayoutText\n" ); - Vector2* glyphPositionsBuffer = glyphPositions.Begin(); + 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; ) @@ -351,7 +387,8 @@ 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 ); @@ -366,60 +403,112 @@ struct LayoutEngine::Impl 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; - position.x = penX + glyph.xBearing; - position.y = penY - glyph.yBearing; + actualSize.width = layoutParameters.boundingBox.width; + actualSize.height += ( lineRun.ascender + -lineRun.descender ); - penX += glyph.advance; + 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; } + 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 ); - penY += -layout.descender; + SetGlyphPositions( layoutParameters.glyphsBuffer + index, + layout.numberOfGlyphs, + penY, + glyphPositions.Begin() + index ); - // Increase the glyph index. - index += layout.numberOfGlyphs; + penY += -layout.descender; + + // Increase the glyph index. + index += layout.numberOfGlyphs; + } } DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--LayoutText\n\n" ); + return true; } @@ -468,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 ) @@ -554,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; @@ -584,6 +629,8 @@ struct LayoutEngine::Impl LayoutEngine::VerticalAlignment mVerticalAlignment; TextAbstraction::FontClient mFontClient; + + bool mEllipsisEnabled:1; }; LayoutEngine::LayoutEngine() @@ -607,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; @@ -645,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