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=6a06e58a31b24f266aff67f4340c87fa1bbf361f;hp=bb7cdde42f9953f1d6cd08e8991a8fa9d52d93fa;hb=528aa3699cd51dab5115bca1aaebb65d4bc67c15;hpb=b766a879a8f8b55a7017847894a2f1bc7edd83d8 diff --git a/dali-toolkit/internal/text/visual-model-impl.cpp b/dali-toolkit/internal/text/visual-model-impl.cpp old mode 100644 new mode 100755 index bb7cdde..6a06e58 --- 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) 2019 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. @@ -35,29 +35,50 @@ VisualModelPtr VisualModel::New() 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 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(), + GlyphIndex glyphIndex = startGlyphIndex; + CharacterIndex characterIndex = startIndex; + const CharacterIndex lastCharacterIndexPlusOne = startIndex + numberOfCharacters; + for( Vector::ConstIterator it = mCharactersPerGlyph.Begin() + glyphIndex, endIt = mCharactersPerGlyph.End(); - it != endIt; + ( it != endIt ) && ( characterIndex < lastCharacterIndexPlusOne ); ++it ) { const Length numberOfCharactersPerGlyph = *it; @@ -66,34 +87,78 @@ void VisualModel::CreateCharacterToGlyphTable( Length numberOfCharacters ) // Set the glyph indices. for( Length index = 0u; index < numberOfCharactersPerGlyph; ++index, ++characterIndex ) { - mCharactersToGlyph.PushBack( glyphIndex ); + *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 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(), + for( Vector::ConstIterator it = mCharactersPerGlyph.Begin() + startGlyphIndex, endIt = mCharactersPerGlyph.End(); - it != endIt; + ( it != endIt ) && ( traversedCharacters < numberOfCharacters ); ++it ) { const Length numberOfCharactersPerGlyph = *it; + traversedCharacters += numberOfCharactersPerGlyph; // Set the glyphs per character. if( 0u == numberOfCharactersPerGlyph ) @@ -103,16 +168,30 @@ void VisualModel::CreateGlyphsPerCharacterTable( Length numberOfCharacters ) else { const Length numberOfZeroGlyphsPerCharacter = ( numberOfCharactersPerGlyph - 1u ); - for( Length zeroIndex = 0u; zeroIndex < numberOfZeroGlyphsPerCharacter ; ++zeroIndex ) + 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, @@ -149,13 +228,13 @@ void VisualModel::GetNumberOfLines( GlyphIndex glyphIndex, { 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( lastGlyphIndex <= line.glyphIndex ) + else if( lastGlyphIndex <= line.glyphRun.glyphIndex ) { // nothing else to do. break; @@ -185,18 +264,21 @@ void VisualModel::GetLinesOfGlyphRange( LineRun* lines, LineIndex VisualModel::GetLineOfCharacter( CharacterIndex characterIndex ) { - // 1) Check first in the cached line. + // 1) Check line is empty or not. + if( mLines.Empty() ) + { + return 0u; + } + // 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, @@ -216,6 +298,15 @@ LineIndex VisualModel::GetLineOfCharacter( CharacterIndex characterIndex ) return index; } +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; @@ -226,14 +317,14 @@ 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 ) @@ -256,12 +347,22 @@ void VisualModel::SetShadowColor( const Vector4& shadowColor ) mShadowColor = shadowColor; } +void VisualModel::SetShadowBlurRadius( const float& shadowBlurRadius ) +{ + mShadowBlurRadius = shadowBlurRadius; +} + void VisualModel::SetUnderlineColor( const Vector4& color ) { mUnderlineColor = color; mUnderlineColorSet = true; } +void VisualModel::SetOutlineColor( const Vector4& color ) +{ + mOutlineColor = color; +} + void VisualModel::SetUnderlineEnabled( bool enabled ) { mUnderlineEnabled = enabled; @@ -272,6 +373,21 @@ 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; +} + const Vector4& VisualModel::GetTextColor() const { return mTextColor; @@ -287,11 +403,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; @@ -302,6 +428,26 @@ 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; +} + +Length VisualModel::GetNumberOfUnderlineRuns() const +{ + return mUnderlineRuns.Count(); +} + void VisualModel::ClearCaches() { mCachedLineIndex = 0u; @@ -322,13 +468,19 @@ VisualModel::VisualModel() mTextColor( Color::BLACK ), mShadowColor( Color::BLACK ), mUnderlineColor( Color::BLACK ), - mShadowOffset( Vector2::ZERO ), + mOutlineColor( Color::WHITE ), + mBackgroundColor( Color::TRANSPARENT ), + mControlSize(), + mShadowOffset(), mUnderlineHeight( 0.0f ), + mShadowBlurRadius( 0.0f ), + mOutlineWidth( 0u ), mNaturalSize(), - mActualSize(), + mLayoutSize(), mCachedLineIndex( 0u ), mUnderlineEnabled( false ), - mUnderlineColorSet( false ) + mUnderlineColorSet( false ), + mBackgroundEnabled( false ) { }