X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Ftext-view.cpp;h=83ad28fd8aba8e4bcc8b824c6a8a7b2e1083103c;hb=d74d70d51ed70b00e29a2b6feac5419124fffc49;hp=e7bd2629c388191176addcea1946fa6acd6f3c5d;hpb=e82c3165d7d7eeaa8cd8c911ab73b1ed2f46ddf4;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/text/text-view.cpp b/dali-toolkit/internal/text/text-view.cpp index e7bd262..83ad28f 100644 --- a/dali-toolkit/internal/text/text-view.cpp +++ b/dali-toolkit/internal/text/text-view.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,26 +19,23 @@ #include // EXTERNAL INCLUDES +#include #include -#include namespace Dali { - namespace Toolkit { - namespace Text { - struct View::Impl { - VisualModelPtr mVisualModel; + VisualModelPtr mVisualModel; TextAbstraction::FontClient mFontClient; ///< Handle to the font client. }; View::View() -: mImpl( NULL ) +: mImpl(NULL) { mImpl = new View::Impl(); @@ -50,137 +47,255 @@ View::~View() delete mImpl; } -void View::SetVisualModel( VisualModelPtr visualModel ) +void View::SetVisualModel(VisualModelPtr visualModel) { mImpl->mVisualModel = visualModel; } -Length View::GetGlyphs( GlyphInfo* glyphs, - Vector2* glyphPositions, - GlyphIndex glyphIndex, - Length numberOfGlyphs ) const +const Vector2& View::GetControlSize() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->mControlSize; + } + + return Vector2::ZERO; +} + +const Vector2& View::GetLayoutSize() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->GetLayoutSize(); + } + + return Vector2::ZERO; +} + +Length View::GetNumberOfGlyphs() const +{ + if(mImpl->mVisualModel) + { + const VisualModel& model = *mImpl->mVisualModel; + + const Length glyphCount = model.mGlyphs.Count(); + const Length positionCount = model.mGlyphPositions.Count(); + + DALI_ASSERT_DEBUG(positionCount <= glyphCount && "Invalid glyph positions in Model"); + + return (positionCount < glyphCount) ? positionCount : glyphCount; + } + + return 0; +} + +Length View::GetGlyphs(GlyphInfo* glyphs, + Vector2* glyphPositions, + float& minLineOffset, + GlyphIndex glyphIndex, + Length numberOfGlyphs) const { Length numberOfLaidOutGlyphs = 0u; - if( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { // If ellipsis is enabled, the number of glyphs the layout engine has laid out may be less than 'numberOfGlyphs'. // Check the last laid out line to know if the layout engine elided some text. - const Length numberOfLines = mImpl->mVisualModel->GetNumberOfLines(); - if( numberOfLines > 0u ) + const Length numberOfLines = mImpl->mVisualModel->mLines.Count(); + if(numberOfLines > 0u) { - const LineRun& lastLine = *( mImpl->mVisualModel->mLines.Begin() + ( numberOfLines - 1u ) ); + const LineRun& lastLine = *(mImpl->mVisualModel->mLines.Begin() + (numberOfLines - 1u)); // If ellipsis is enabled, calculate the number of laid out glyphs. // Otherwise use the given number of glyphs. - if( lastLine.ellipsis ) + if(lastLine.ellipsis) { - numberOfLaidOutGlyphs = lastLine.glyphIndex + lastLine.numberOfGlyphs; + numberOfLaidOutGlyphs = lastLine.glyphRun.glyphIndex + lastLine.glyphRun.numberOfGlyphs; } else { numberOfLaidOutGlyphs = numberOfGlyphs; } - // Retrieve from the visual model the glyphs and positions. - mImpl->mVisualModel->GetGlyphs( glyphs, - glyphIndex, - numberOfLaidOutGlyphs ); - - mImpl->mVisualModel->GetGlyphPositions( glyphPositions, - glyphIndex, - numberOfLaidOutGlyphs ); - - if( 1u == numberOfLaidOutGlyphs ) - { - // not a point try to do ellipsis with only one laid out character. - return numberOfLaidOutGlyphs; - } - - if( lastLine.ellipsis ) + if(0u < numberOfLaidOutGlyphs) { - // firstPenX, penY and firstPenSet are used to position the ellipsis glyph if needed. - float firstPenX = 0.f; // Used if rtl text is elided. - float penY = 0.f; - bool firstPenSet = false; - - // Add the ellipsis glyph. - bool inserted = false; - float removedGlypsWidth = 0.f; - Length numberOfRemovedGlyphs = 0u; - GlyphIndex index = numberOfLaidOutGlyphs - 1u; - - // The ellipsis glyph has to fit in the place where the last glyph(s) is(are) removed. - while( !inserted ) + // Retrieve from the visual model the glyphs and positions. + mImpl->mVisualModel->GetGlyphs(glyphs, + glyphIndex, + numberOfLaidOutGlyphs); + + mImpl->mVisualModel->GetGlyphPositions(glyphPositions, + glyphIndex, + numberOfLaidOutGlyphs); + + // Get the lines for the given range of glyphs. + // The lines contain the alignment offset which needs to be added to the glyph's position. + LineIndex firstLine = 0u; + Length numberOfLines = 0u; + mImpl->mVisualModel->GetNumberOfLines(glyphIndex, + numberOfLaidOutGlyphs, + firstLine, + numberOfLines); + + Vector lines; + lines.Resize(numberOfLines); + LineRun* lineBuffer = lines.Begin(); + + mImpl->mVisualModel->GetLinesOfGlyphRange(lineBuffer, + glyphIndex, + numberOfLaidOutGlyphs); + + // Get the first line for the given glyph range. + LineIndex lineIndex = firstLine; + LineRun* line = lineBuffer + lineIndex; + + // Index of the last glyph of the line. + GlyphIndex lastGlyphIndexOfLine = line->glyphRun.glyphIndex + line->glyphRun.numberOfGlyphs - 1u; + + // Add the alignment offset to the glyph's position. + + minLineOffset = line->alignmentOffset; + float penY = line->ascender; + for(Length index = 0u; index < numberOfLaidOutGlyphs; ++index) { - const GlyphInfo& glyphToRemove = *( glyphs + index ); + Vector2& position = *(glyphPositions + index); + position.x += line->alignmentOffset; + position.y += penY; - // Need to reshape the glyph as the font may be different in size. - const GlyphInfo& ellipsisGlyph = mImpl->mFontClient.GetEllipsisGlyph( mImpl->mFontClient.GetPointSize( glyphToRemove.fontId ) ); - - if( !firstPenSet ) + if(lastGlyphIndexOfLine == index) { - const Vector2& position = *( glyphPositions + index ); + penY += -line->descender; - // Calculates the penY of the current line. It will be used to position the ellipsis glyph. - penY = position.y + glyphToRemove.yBearing; + // Get the next line. + ++lineIndex; - // Calculates the first penX which will be used if rtl text is elided. - firstPenX = position.x - glyphToRemove.xBearing; - if( firstPenX < -ellipsisGlyph.xBearing ) + if(lineIndex < numberOfLines) { - // Avoids to exceed the bounding box when rtl text is elided. - firstPenX = -ellipsisGlyph.xBearing; - } + line = lineBuffer + lineIndex; + minLineOffset = std::min(minLineOffset, line->alignmentOffset); - removedGlypsWidth = -ellipsisGlyph.xBearing; + lastGlyphIndexOfLine = line->glyphRun.glyphIndex + line->glyphRun.numberOfGlyphs - 1u; - firstPenSet = true; + penY += line->ascender; + } } + } - removedGlypsWidth += std::min( glyphToRemove.advance, ( glyphToRemove.xBearing + glyphToRemove.width ) ); + if(1u == numberOfLaidOutGlyphs) + { + // not a point try to do ellipsis with only one laid out character. + return numberOfLaidOutGlyphs; + } - // Calculate the width of the ellipsis glyph and check if it fits. - const float ellipsisGlyphWidth = ellipsisGlyph.width + ellipsisGlyph.xBearing; - if( ellipsisGlyphWidth < removedGlypsWidth ) + if(lastLine.ellipsis) + { + if((1u == numberOfLines) && + (lastLine.ascender - lastLine.descender > mImpl->mVisualModel->mControlSize.height)) { - GlyphInfo& glyphInfo = *( glyphs + index ); - Vector2& position = *( glyphPositions + index ); - position.x -= glyphInfo.xBearing; + // Get the first glyph which is going to be replaced and the ellipsis glyph. + GlyphInfo& glyphInfo = *glyphs; + const GlyphInfo& ellipsisGlyph = mImpl->mFontClient.GetEllipsisGlyph(mImpl->mFontClient.GetPointSize(glyphInfo.fontId)); + + // Change the 'x' and 'y' position of the ellipsis glyph. + Vector2& position = *glyphPositions; + position.x = ellipsisGlyph.xBearing; + position.y = mImpl->mVisualModel->mControlSize.height - ellipsisGlyph.yBearing; // Replace the glyph by the ellipsis glyph. glyphInfo = ellipsisGlyph; - // Change the 'x' and 'y' position of the ellipsis glyph. + return 1u; + } - if( position.x > firstPenX ) - { - position.x = firstPenX + removedGlypsWidth - ellipsisGlyphWidth; - } + // firstPenX, penY and firstPenSet are used to position the ellipsis glyph if needed. + float firstPenX = 0.f; // Used if rtl text is elided. + float penY = 0.f; + bool firstPenSet = false; - position.x += ellipsisGlyph.xBearing; - position.y = penY - ellipsisGlyph.yBearing; + // Add the ellipsis glyph. + bool inserted = false; + float removedGlypsWidth = 0.f; + Length numberOfRemovedGlyphs = 0u; + GlyphIndex index = numberOfLaidOutGlyphs - 1u; - inserted = true; - } - else + // The ellipsis glyph has to fit in the place where the last glyph(s) is(are) removed. + while(!inserted) { - if( index > 0u ) + const GlyphInfo& glyphToRemove = *(glyphs + index); + + if(0u != glyphToRemove.fontId) { - --index; + // i.e. The font id of the glyph shaped from the '\n' character is zero. + + // Need to reshape the glyph as the font may be different in size. + const GlyphInfo& ellipsisGlyph = mImpl->mFontClient.GetEllipsisGlyph(mImpl->mFontClient.GetPointSize(glyphToRemove.fontId)); + + if(!firstPenSet) + { + const Vector2& position = *(glyphPositions + index); + + // Calculates the penY of the current line. It will be used to position the ellipsis glyph. + penY = position.y + glyphToRemove.yBearing; + + // Calculates the first penX which will be used if rtl text is elided. + firstPenX = position.x - glyphToRemove.xBearing; + if(firstPenX < -ellipsisGlyph.xBearing) + { + // Avoids to exceed the bounding box when rtl text is elided. + firstPenX = -ellipsisGlyph.xBearing; + } + + removedGlypsWidth = -ellipsisGlyph.xBearing; + + firstPenSet = true; + } + + removedGlypsWidth += std::min(glyphToRemove.advance, (glyphToRemove.xBearing + glyphToRemove.width)); + + // Calculate the width of the ellipsis glyph and check if it fits. + const float ellipsisGlyphWidth = ellipsisGlyph.width + ellipsisGlyph.xBearing; + if(ellipsisGlyphWidth < removedGlypsWidth) + { + GlyphInfo& glyphInfo = *(glyphs + index); + Vector2& position = *(glyphPositions + index); + position.x -= (0.f > glyphInfo.xBearing) ? glyphInfo.xBearing : 0.f; + + // Replace the glyph by the ellipsis glyph. + glyphInfo = ellipsisGlyph; + + // Change the 'x' and 'y' position of the ellipsis glyph. + + if(position.x > firstPenX) + { + position.x = firstPenX + removedGlypsWidth - ellipsisGlyphWidth; + } + + position.x += ellipsisGlyph.xBearing; + position.y = penY - ellipsisGlyph.yBearing; + + inserted = true; + } } - else + + if(!inserted) { - // No space for the ellipsis. - inserted = true; + if(index > 0u) + { + --index; + } + else + { + // No space for the ellipsis. + inserted = true; + } + ++numberOfRemovedGlyphs; } - ++numberOfRemovedGlyphs; } - } - // 'Removes' all the glyphs after the ellipsis glyph. - numberOfLaidOutGlyphs -= numberOfRemovedGlyphs; + // 'Removes' all the glyphs after the ellipsis glyph. + numberOfLaidOutGlyphs -= numberOfRemovedGlyphs; + } } } } @@ -188,81 +303,138 @@ Length View::GetGlyphs( GlyphInfo* glyphs, return numberOfLaidOutGlyphs; } +const Vector4* const View::GetColors() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->mColors.Begin(); + } + + return NULL; +} + +const ColorIndex* const View::GetColorIndices() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->mColorIndices.Begin(); + } + + return NULL; +} + +const Vector4* const View::GetBackgroundColors() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->mBackgroundColors.Begin(); + } + + return nullptr; +} + +const ColorIndex* const View::GetBackgroundColorIndices() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->mBackgroundColorIndices.Begin(); + } + + return nullptr; +} + const Vector4& View::GetTextColor() const { - if ( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { - VisualModel& model = *mImpl->mVisualModel; - return model.GetTextColor(); + return mImpl->mVisualModel->GetTextColor(); } return Vector4::ZERO; } const Vector2& View::GetShadowOffset() const { - if ( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { - VisualModel& model = *mImpl->mVisualModel; - return model.GetShadowOffset(); + return mImpl->mVisualModel->GetShadowOffset(); } return Vector2::ZERO; } const Vector4& View::GetShadowColor() const { - if ( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { - VisualModel& model = *mImpl->mVisualModel; - return model.GetShadowColor(); + return mImpl->mVisualModel->GetShadowColor(); } return Vector4::ZERO; } const Vector4& View::GetUnderlineColor() const { - if ( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { - VisualModel& model = *mImpl->mVisualModel; - return model.GetUnderlineColor(); + return mImpl->mVisualModel->GetUnderlineColor(); } return Vector4::ZERO; } bool View::IsUnderlineEnabled() const { - if ( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { - VisualModel& model = *mImpl->mVisualModel; - return model.IsUnderlineEnabled(); + return mImpl->mVisualModel->IsUnderlineEnabled(); } return false; } float View::GetUnderlineHeight() const { - if ( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { - VisualModel& model = *mImpl->mVisualModel; - return model.GetUnderlineHeight(); + return mImpl->mVisualModel->GetUnderlineHeight(); } return 0.0f; } -Length View::GetNumberOfGlyphs() const +Length View::GetNumberOfUnderlineRuns() const { - if( mImpl->mVisualModel ) + if(mImpl->mVisualModel) { - VisualModel& model = *mImpl->mVisualModel; + return mImpl->mVisualModel->GetNumberOfUnderlineRuns(); + } - Length glyphCount = model.GetNumberOfGlyphs(); - Length positionCount = model.GetNumberOfGlyphPositions(); + return 0u; +} - DALI_ASSERT_DEBUG( positionCount <= glyphCount && "Invalid glyph positions in Model" ); +void View::GetUnderlineRuns(GlyphRun* underlineRuns, + UnderlineRunIndex index, + Length numberOfRuns) const +{ + if(mImpl->mVisualModel) + { + mImpl->mVisualModel->GetUnderlineRuns(underlineRuns, + index, + numberOfRuns); + } +} - return (positionCount < glyphCount) ? positionCount : glyphCount; +const Vector4& View::GetOutlineColor() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->GetOutlineColor(); } + return Vector4::ZERO; +} - return 0; +uint16_t View::GetOutlineWidth() const +{ + if(mImpl->mVisualModel) + { + return mImpl->mVisualModel->GetOutlineWidth(); + } + return 0u; } } // namespace Text