X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Fvisual-model-impl.cpp;h=5fa384335036580b94e7e9feb557cb550e34ce31;hp=a354fdc313ea3774143d3ced6bba0c2ce74ef7e9;hb=7c13cc0c065ae22e7ad0deaea4f56730ff050c5c;hpb=24ab5420ad958de9ba345b504de62881162c754b diff --git a/dali-toolkit/internal/text/visual-model-impl.cpp b/dali-toolkit/internal/text/visual-model-impl.cpp index a354fdc..5fa3843 100644 --- a/dali-toolkit/internal/text/visual-model-impl.cpp +++ b/dali-toolkit/internal/text/visual-model-impl.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. @@ -20,194 +20,277 @@ // EXTERNAL INCLUDES #include -#include namespace Dali { - namespace Toolkit { - namespace Text { - VisualModelPtr VisualModel::New() { - return VisualModelPtr( new VisualModel() ); + return VisualModelPtr(new VisualModel()); } -void VisualModel::CreateCharacterToGlyphTable( Length numberOfCharacters ) +void VisualModel::CreateCharacterToGlyphTable(CharacterIndex startIndex, + GlyphIndex startGlyphIndex, + Length numberOfCharacters) { - // 1) Reserve some space for the characters to avoid reallocations. - if( 0u == numberOfCharacters ) + if(0u == numberOfCharacters) { - // If no number of characters is given, just set something sensible to avoid reallocations. - numberOfCharacters = static_cast ( static_cast( mGlyphs.Count() ) * 1.3f ); + // Nothing to do. + return; } - mCharactersToGlyph.Reserve( numberOfCharacters ); - DALI_ASSERT_DEBUG( mGlyphsPerCharacter.Count() != 0u || - ( 0u == numberOfCharacters ) ); + DALI_ASSERT_DEBUG(mGlyphsPerCharacter.Count() != 0u); + + // Get the total number of characters. + const Length totalNumberOfCharacters = (0u == mGlyphsToCharacters.Count()) ? 0u : *(mGlyphsToCharacters.End() - 1u) + *(mCharactersPerGlyph.End() - 1u); // Index to the first character + the number of characters that form the last glyph. + + // Whether the current buffer is being updated or is set from scratch. + const bool updateCurrentBuffer = numberOfCharacters < totalNumberOfCharacters; + + Vector newCharactersToGlyph; + GlyphIndex* charactersToGlyphBuffer = NULL; + + // 1) Reserve some space for the glyph indices to avoid reallocations. + if(updateCurrentBuffer) + { + newCharactersToGlyph.Resize(numberOfCharacters); + charactersToGlyphBuffer = newCharactersToGlyph.Begin(); + } + else + { + mCharactersToGlyph.Resize(numberOfCharacters); + charactersToGlyphBuffer = mCharactersToGlyph.Begin() + startIndex; + } const Length* const glyphsPerCharacterBuffer = mGlyphsPerCharacter.Begin(); // 2) Traverse the glyphs and set the glyph indices per character. // Index to the glyph. - GlyphIndex glyphIndex = 0u; - CharacterIndex characterIndex = 0u; - for( Vector::ConstIterator it = mCharactersPerGlyph.Begin(), - endIt = mCharactersPerGlyph.End(); - it != endIt; - ++it ) + GlyphIndex glyphIndex = startGlyphIndex; + CharacterIndex characterIndex = startIndex; + const CharacterIndex lastCharacterIndexPlusOne = startIndex + numberOfCharacters; + for(Vector::ConstIterator it = mCharactersPerGlyph.Begin() + glyphIndex, + endIt = mCharactersPerGlyph.End(); + (it != endIt) && (characterIndex < lastCharacterIndexPlusOne); + ++it) { const Length numberOfCharactersPerGlyph = *it; Length numberOfGlyphs = 0u; // Set the glyph indices. - for( Length index = 0u; index < numberOfCharactersPerGlyph; ++index, ++characterIndex ) + for(Length index = 0u; index < numberOfCharactersPerGlyph; ++index, ++characterIndex) { - mCharactersToGlyph.PushBack( glyphIndex ); - numberOfGlyphs += *( glyphsPerCharacterBuffer + characterIndex ); + *charactersToGlyphBuffer = glyphIndex; + numberOfGlyphs += *(glyphsPerCharacterBuffer + characterIndex); + ++charactersToGlyphBuffer; } glyphIndex += numberOfGlyphs; } + + // If the character to glyph buffer is updated, it needs to be inserted in the model. + if(updateCurrentBuffer) + { + // Update the indices. + const Length numberOfGlyphs = glyphIndex - startGlyphIndex; + for(Vector::Iterator it = mCharactersToGlyph.Begin() + startIndex, + endIt = mCharactersToGlyph.End(); + it != endIt; + ++it) + { + *it += numberOfGlyphs; + } + + mCharactersToGlyph.Insert(mCharactersToGlyph.Begin() + startIndex, + newCharactersToGlyph.Begin(), + newCharactersToGlyph.End()); + } } -void VisualModel::CreateGlyphsPerCharacterTable( Length numberOfCharacters ) +void VisualModel::CreateGlyphsPerCharacterTable(CharacterIndex startIndex, + GlyphIndex startGlyphIndex, + Length numberOfCharacters) { - // 1) Reserve some space for the characters to avoid reallocations. - if( 0u == numberOfCharacters ) + if(0u == numberOfCharacters) { - // If no number of characters is given, just set something sensible to avoid reallocations. - numberOfCharacters = static_cast ( static_cast( mGlyphs.Count() ) * 1.3f ); + // Nothing to do. + return; + } + + // Get the total number of characters. + const Length totalNumberOfCharacters = (0u == mGlyphsToCharacters.Count()) ? 0u : *(mGlyphsToCharacters.End() - 1u) + *(mCharactersPerGlyph.End() - 1u); // Index to the first character + the number of characters that form the last glyph. + + // Whether the current buffer is being updated or is set from scratch. + const bool updateCurrentBuffer = numberOfCharacters < totalNumberOfCharacters; + + Vector newGlyphsPerCharacter; + Length* glyphsPerCharacterBuffer = NULL; + + // 1) Reserve some space for the glyphs per character to avoid reallocations. + if(updateCurrentBuffer) + { + newGlyphsPerCharacter.Resize(numberOfCharacters); + glyphsPerCharacterBuffer = newGlyphsPerCharacter.Begin(); + } + else + { + mGlyphsPerCharacter.Resize(numberOfCharacters); + glyphsPerCharacterBuffer = mGlyphsPerCharacter.Begin() + startIndex; } - mGlyphsPerCharacter.Reserve( numberOfCharacters ); // 2) Traverse the glyphs and set the number of glyphs per character. + Length traversedCharacters = 0; + // The number of 'characters per glyph' equal to zero. Length zeroCharactersPerGlyph = 0u; - for( Vector::ConstIterator it = mCharactersPerGlyph.Begin(), - endIt = mCharactersPerGlyph.End(); - it != endIt; - ++it ) + for(Vector::ConstIterator it = mCharactersPerGlyph.Begin() + startGlyphIndex, + endIt = mCharactersPerGlyph.End(); + (it != endIt) && (traversedCharacters < numberOfCharacters); + ++it) { const Length numberOfCharactersPerGlyph = *it; + traversedCharacters += numberOfCharactersPerGlyph; // Set the glyphs per character. - if( 0u == numberOfCharactersPerGlyph ) + if(0u == numberOfCharactersPerGlyph) { ++zeroCharactersPerGlyph; } else { - const Length numberOfZeroGlyphsPerCharacter = ( numberOfCharactersPerGlyph - 1u ); - for( Length zeroIndex = 0u; zeroIndex < numberOfZeroGlyphsPerCharacter ; ++zeroIndex ) + const Length numberOfZeroGlyphsPerCharacter = (numberOfCharactersPerGlyph - 1u); + for(Length zeroIndex = 0u; zeroIndex < numberOfZeroGlyphsPerCharacter; ++zeroIndex) { - mGlyphsPerCharacter.PushBack( 0u ); + *glyphsPerCharacterBuffer = 0u; + + // Point to the next position in the buffer. + ++glyphsPerCharacterBuffer; } - mGlyphsPerCharacter.PushBack( 1u + zeroCharactersPerGlyph ); + *glyphsPerCharacterBuffer = zeroCharactersPerGlyph + 1u; zeroCharactersPerGlyph = 0u; + + // Point to the next position in the buffer. + ++glyphsPerCharacterBuffer; } } + + // If the glyphs per character buffer is updated, it needs to be inserted in the model. + if(updateCurrentBuffer) + { + mGlyphsPerCharacter.Insert(mGlyphsPerCharacter.Begin() + startIndex, + newGlyphsPerCharacter.Begin(), + newGlyphsPerCharacter.End()); + } } -void VisualModel::GetGlyphs( GlyphInfo* glyphs, - GlyphIndex glyphIndex, - Length numberOfGlyphs ) const +void VisualModel::GetGlyphs(GlyphInfo* glyphs, + GlyphIndex glyphIndex, + Length numberOfGlyphs) const { - memcpy( glyphs, mGlyphs.Begin() + glyphIndex, numberOfGlyphs * sizeof( GlyphInfo ) ); + memcpy(glyphs, mGlyphs.Begin() + glyphIndex, numberOfGlyphs * sizeof(GlyphInfo)); } -void VisualModel::GetGlyphPositions( Vector2* glyphPositions, - GlyphIndex glyphIndex, - Length numberOfGlyphs ) const +void VisualModel::GetGlyphPositions(Vector2* glyphPositions, + GlyphIndex glyphIndex, + Length numberOfGlyphs) const { - memcpy( glyphPositions, mGlyphPositions.Begin() + glyphIndex, numberOfGlyphs * sizeof( Vector2 ) ); + memcpy(glyphPositions, mGlyphPositions.Begin() + glyphIndex, numberOfGlyphs * sizeof(Vector2)); } -void VisualModel::GetNumberOfLines( GlyphIndex glyphIndex, - Length numberOfGlyphs, - LineIndex& firstLine, - Length& numberOfLines ) const +void VisualModel::GetNumberOfLines(GlyphIndex glyphIndex, + Length numberOfGlyphs, + LineIndex& firstLine, + Length& numberOfLines) const { // Initialize the number of lines and the first line. - firstLine = 0u; - numberOfLines = 0u; + firstLine = 0u; + numberOfLines = 0u; bool firstLineFound = false; const GlyphIndex lastGlyphIndex = glyphIndex + numberOfGlyphs; // Traverse the lines and count those lines within the range of glyphs. - for( Vector::ConstIterator it = mLines.Begin(), - endIt = mLines.End(); - it != endIt; - ++it ) + for(Vector::ConstIterator it = mLines.Begin(), + endIt = mLines.End(); + it != endIt; + ++it) { const LineRun& line = *it; - if( ( line.glyphIndex + line.numberOfGlyphs > glyphIndex ) && - ( lastGlyphIndex > line.glyphIndex ) ) + if((line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs > glyphIndex) && + (lastGlyphIndex > line.glyphRun.glyphIndex)) + { + firstLineFound = true; + ++numberOfLines; + } + else if((line.glyphRunSecondHalf.glyphIndex + line.glyphRunSecondHalf.numberOfGlyphs > glyphIndex) && + (lastGlyphIndex > line.glyphRunSecondHalf.glyphIndex)) { firstLineFound = true; ++numberOfLines; } - else if( lastGlyphIndex <= line.glyphIndex ) + else if(lastGlyphIndex <= line.glyphRun.glyphIndex) { // nothing else to do. break; } - if( !firstLineFound ) + if(!firstLineFound) { ++firstLine; } } } -void VisualModel::GetLinesOfGlyphRange( LineRun* lines, - GlyphIndex glyphIndex, - Length numberOfGlyphs ) const +void VisualModel::GetLinesOfGlyphRange(LineRun* lines, + GlyphIndex glyphIndex, + Length numberOfGlyphs) const { - LineIndex firstLine = 0u; - Length numberOfLines = 0u; + LineIndex firstLine = 0u; + Length numberOfLines = 0u; - GetNumberOfLines( glyphIndex, - numberOfGlyphs, - firstLine, - numberOfLines ); + GetNumberOfLines(glyphIndex, + numberOfGlyphs, + firstLine, + numberOfLines); - memcpy( lines, mLines.Begin() + firstLine, numberOfLines * sizeof( LineRun ) ); + memcpy(lines, mLines.Begin() + firstLine, numberOfLines * sizeof(LineRun)); } -LineIndex VisualModel::GetLineOfCharacter( CharacterIndex characterIndex ) +LineIndex VisualModel::GetLineOfCharacter(CharacterIndex characterIndex) { - // 1) Check first in the cached line. - - const LineRun& lineRun = *( mLines.Begin() + mCachedLineIndex ); + // 1) Check line is empty or not. + if(mLines.Empty()) + { + return 0u; + } - if( ( lineRun.characterRun.characterIndex <= characterIndex ) && - ( characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters ) ) + // 2) Check in the cached line. + const LineRun& lineRun = *(mLines.Begin() + mCachedLineIndex); + if((lineRun.characterRun.characterIndex <= characterIndex) && + (characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters)) { return mCachedLineIndex; } - // 2) Is not in the cached line. Check in the other lines. - + // 3) Is not in the cached line. Check in the other lines. LineIndex index = characterIndex < lineRun.characterRun.characterIndex ? 0u : mCachedLineIndex + 1u; - for( Vector::ConstIterator it = mLines.Begin() + index, - endIt = mLines.End(); - it != endIt; - ++it, ++index ) + for(Vector::ConstIterator it = mLines.Begin() + index, + endIt = mLines.End(); + it != endIt; + ++it, ++index) { const LineRun& lineRun = *it; - if( characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters ) + if(characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters) { mCachedLineIndex = index; break; @@ -217,7 +300,16 @@ LineIndex VisualModel::GetLineOfCharacter( CharacterIndex characterIndex ) return index; } -void VisualModel::SetNaturalSize( const Vector2& size ) +void VisualModel::GetUnderlineRuns(GlyphRun* underlineRuns, + UnderlineRunIndex index, + Length numberOfRuns) const +{ + memcpy(underlineRuns, + mUnderlineRuns.Begin() + index, + numberOfRuns * sizeof(GlyphRun)); +} + +void VisualModel::SetNaturalSize(const Vector2& size) { mNaturalSize = size; } @@ -227,52 +319,112 @@ const Vector2& VisualModel::GetNaturalSize() const return mNaturalSize; } -void VisualModel::SetActualSize( const Vector2& size ) +void VisualModel::SetLayoutSize(const Vector2& size) { - mActualSize = size; + mLayoutSize = size; } -const Vector2& VisualModel::GetActualSize() const +const Vector2& VisualModel::GetLayoutSize() const { - return mActualSize; + return mLayoutSize; } -void VisualModel::SetTextColor( const Vector4& textColor ) +void VisualModel::SetTextColor(const Vector4& textColor) { mTextColor = textColor; - if ( !mUnderlineColorSet ) + if(!mUnderlineColorSet) { mUnderlineColor = textColor; } } -void VisualModel::SetShadowOffset( const Vector2& shadowOffset ) +void VisualModel::SetShadowOffset(const Vector2& shadowOffset) { mShadowOffset = shadowOffset; } -void VisualModel::SetShadowColor( const Vector4& shadowColor ) +void VisualModel::SetShadowColor(const Vector4& shadowColor) { mShadowColor = shadowColor; } -void VisualModel::SetUnderlineColor( const Vector4& color ) +void VisualModel::SetShadowBlurRadius(const float& shadowBlurRadius) +{ + mShadowBlurRadius = shadowBlurRadius; +} + +void VisualModel::SetUnderlineColor(const Vector4& color) { - mUnderlineColor = color; + mUnderlineColor = color; mUnderlineColorSet = true; } -void VisualModel::SetUnderlineEnabled( bool enabled ) +void VisualModel::SetOutlineColor(const Vector4& color) +{ + mOutlineColor = color; +} + +void VisualModel::SetUnderlineEnabled(bool enabled) { mUnderlineEnabled = enabled; } -void VisualModel::SetUnderlineHeight( float height ) +void VisualModel::SetUnderlineHeight(float height) { mUnderlineHeight = height; } +void VisualModel::SetOutlineWidth(uint16_t width) +{ + mOutlineWidth = width; +} + +void VisualModel::SetBackgroundColor(const Vector4& color) +{ + mBackgroundColor = color; +} + +void VisualModel::SetBackgroundEnabled(bool enabled) +{ + mBackgroundEnabled = enabled; +} + +void VisualModel::SetMarkupProcessorEnabled(bool enabled) +{ + mMarkupProcessorEnabled = enabled; +} + +void VisualModel::SetTextElideEnabled(bool enabled) +{ + mTextElideEnabled = enabled; +} + +void VisualModel::SetEllipsisPosition(Toolkit::DevelText::EllipsisPosition::Type ellipsisPosition) +{ + mEllipsisPosition = ellipsisPosition; +} + +void VisualModel::SetStartIndexOfElidedGlyphs(GlyphIndex startIndexOfElidedGlyphs) +{ + mStartIndexOfElidedGlyphs = startIndexOfElidedGlyphs; +} + +void VisualModel::SetEndIndexOfElidedGlyphs(GlyphIndex endIndexOfElidedGlyphs) +{ + mEndIndexOfElidedGlyphs = endIndexOfElidedGlyphs; +} + +void VisualModel::SetFirstMiddleIndexOfElidedGlyphs(GlyphIndex firstMiddleIndexOfElidedGlyphs) +{ + mFirstMiddleIndexOfElidedGlyphs = firstMiddleIndexOfElidedGlyphs; +} + +void VisualModel::SetSecondMiddleIndexOfElidedGlyphs(GlyphIndex secondMiddleIndexOfElidedGlyphs) +{ + mSecondMiddleIndexOfElidedGlyphs = secondMiddleIndexOfElidedGlyphs; +} + const Vector4& VisualModel::GetTextColor() const { return mTextColor; @@ -288,11 +440,21 @@ const Vector4& VisualModel::GetShadowColor() const return mShadowColor; } +const float& VisualModel::GetShadowBlurRadius() const +{ + return mShadowBlurRadius; +} + const Vector4& VisualModel::GetUnderlineColor() const { return mUnderlineColor; } +const Vector4& VisualModel::GetOutlineColor() const +{ + return mOutlineColor; +} + bool VisualModel::IsUnderlineEnabled() const { return mUnderlineEnabled; @@ -303,6 +465,61 @@ float VisualModel::GetUnderlineHeight() const return mUnderlineHeight; } +uint16_t VisualModel::GetOutlineWidth() const +{ + return mOutlineWidth; +} + +const Vector4& VisualModel::GetBackgroundColor() const +{ + return mBackgroundColor; +} + +bool VisualModel::IsBackgroundEnabled() const +{ + return mBackgroundEnabled; +} + +bool VisualModel::IsMarkupProcessorEnabled() const +{ + return mMarkupProcessorEnabled; +} + +bool VisualModel::IsTextElideEnabled() const +{ + return mTextElideEnabled; +} + +Toolkit::DevelText::EllipsisPosition::Type VisualModel::GetEllipsisPosition() const +{ + return mEllipsisPosition; +} + +GlyphIndex VisualModel::GetStartIndexOfElidedGlyphs() const +{ + return mStartIndexOfElidedGlyphs; +} + +GlyphIndex VisualModel::GetEndIndexOfElidedGlyphs() const +{ + return mEndIndexOfElidedGlyphs; +} + +GlyphIndex VisualModel::GetFirstMiddleIndexOfElidedGlyphs() const +{ + return mFirstMiddleIndexOfElidedGlyphs; +} + +GlyphIndex VisualModel::GetSecondMiddleIndexOfElidedGlyphs() const +{ + return mSecondMiddleIndexOfElidedGlyphs; +} + +Length VisualModel::GetNumberOfUnderlineRuns() const +{ + return mUnderlineRuns.Count(); +} + void VisualModel::ClearCaches() { mCachedLineIndex = 0u; @@ -320,16 +537,30 @@ VisualModel::VisualModel() mGlyphsPerCharacter(), mGlyphPositions(), mLines(), - mTextColor( Color::BLACK ), - mShadowColor( Color::BLACK ), - mUnderlineColor( Color::BLACK ), - mShadowOffset( Vector2::ZERO ), - mUnderlineHeight( 0.0f ), + mTextColor(Color::BLACK), + mShadowColor(Color::BLACK), + mUnderlineColor(Color::BLACK), + mOutlineColor(Color::WHITE), + mBackgroundColor(Color::TRANSPARENT), + mControlSize(), + mShadowOffset(), + mUnderlineHeight(0.0f), + mShadowBlurRadius(0.0f), + mOutlineWidth(0u), mNaturalSize(), - mActualSize(), - mCachedLineIndex( 0u ), - mUnderlineEnabled( false ), - mUnderlineColorSet( false ) + mLayoutSize(), + mCachedLineIndex(0u), + mEllipsisPosition(DevelText::EllipsisPosition::END), + mStartIndexOfElidedGlyphs(0u), + mEndIndexOfElidedGlyphs(0u), + mFirstMiddleIndexOfElidedGlyphs(0u), + mSecondMiddleIndexOfElidedGlyphs(0u), + mTextElideEnabled(false), + mUnderlineEnabled(false), + mUnderlineColorSet(false), + mBackgroundEnabled(false), + mMarkupProcessorEnabled(false) + { }