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=490bae3b82746f2c5bd9f08f32d7875464edb4a2;hp=3e3f2d67ec0f8ba328c863cedf58e4a32b311c62;hb=4bc73f2e78812b262f09830bb2b1d87034f34496;hpb=4cfc161e92f47722b38d58987ac8f8773bad13c5 diff --git a/dali-toolkit/internal/text/visual-model-impl.cpp b/dali-toolkit/internal/text/visual-model-impl.cpp old mode 100755 new mode 100644 index 3e3f2d6..490bae3 --- a/dali-toolkit/internal/text/visual-model-impl.cpp +++ b/dali-toolkit/internal/text/visual-model-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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. @@ -23,48 +23,45 @@ namespace Dali { - namespace Toolkit { - namespace Text { - VisualModelPtr VisualModel::New() { - return VisualModelPtr( new VisualModel() ); + return VisualModelPtr(new VisualModel()); } -void VisualModel::CreateCharacterToGlyphTable( CharacterIndex startIndex, - GlyphIndex startGlyphIndex, - Length numberOfCharacters ) +void VisualModel::CreateCharacterToGlyphTable(CharacterIndex startIndex, + GlyphIndex startGlyphIndex, + Length numberOfCharacters) { - if( 0u == numberOfCharacters ) + if(0u == numberOfCharacters) { // Nothing to do. return; } - DALI_ASSERT_DEBUG( mGlyphsPerCharacter.Count() != 0u ); + 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. + 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; + GlyphIndex* charactersToGlyphBuffer = NULL; // 1) Reserve some space for the glyph indices to avoid reallocations. - if( updateCurrentBuffer ) + if(updateCurrentBuffer) { - newCharactersToGlyph.Resize( numberOfCharacters ); + newCharactersToGlyph.Resize(numberOfCharacters); charactersToGlyphBuffer = newCharactersToGlyph.Begin(); } else { - mCharactersToGlyph.Resize( numberOfCharacters ); + mCharactersToGlyph.Resize(numberOfCharacters); charactersToGlyphBuffer = mCharactersToGlyph.Begin() + startIndex; } @@ -73,75 +70,74 @@ void VisualModel::CreateCharacterToGlyphTable( CharacterIndex startIndex, // 2) Traverse the glyphs and set the glyph indices per character. // Index to the glyph. - GlyphIndex glyphIndex = startGlyphIndex; - CharacterIndex characterIndex = startIndex; + 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 ) + 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) { *charactersToGlyphBuffer = glyphIndex; - numberOfGlyphs += *( glyphsPerCharacterBuffer + characterIndex ); + numberOfGlyphs += *(glyphsPerCharacterBuffer + characterIndex); ++charactersToGlyphBuffer; } glyphIndex += numberOfGlyphs; } // If the character to glyph buffer is updated, it needs to be inserted in the model. - if( updateCurrentBuffer ) + if(updateCurrentBuffer) { // Update the indices. const Length numberOfGlyphs = glyphIndex - startGlyphIndex; - for( Vector::Iterator it = mCharactersToGlyph.Begin() + startIndex, - endIt = mCharactersToGlyph.End(); - it != endIt; - ++it ) + for(Vector::Iterator it = mCharactersToGlyph.Begin() + startIndex, + endIt = mCharactersToGlyph.End(); + it != endIt; + ++it) { *it += numberOfGlyphs; } - mCharactersToGlyph.Insert( mCharactersToGlyph.Begin() + startIndex, - newCharactersToGlyph.Begin(), - newCharactersToGlyph.End() ); - + mCharactersToGlyph.Insert(mCharactersToGlyph.Begin() + startIndex, + newCharactersToGlyph.Begin(), + newCharactersToGlyph.End()); } } -void VisualModel::CreateGlyphsPerCharacterTable( CharacterIndex startIndex, - GlyphIndex startGlyphIndex, - Length numberOfCharacters ) +void VisualModel::CreateGlyphsPerCharacterTable(CharacterIndex startIndex, + GlyphIndex startGlyphIndex, + Length numberOfCharacters) { - if( 0u == numberOfCharacters ) + if(0u == numberOfCharacters) { // 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. + 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; + Length* glyphsPerCharacterBuffer = NULL; // 1) Reserve some space for the glyphs per character to avoid reallocations. - if( updateCurrentBuffer ) + if(updateCurrentBuffer) { - newGlyphsPerCharacter.Resize( numberOfCharacters ); + newGlyphsPerCharacter.Resize(numberOfCharacters); glyphsPerCharacterBuffer = newGlyphsPerCharacter.Begin(); } else { - mGlyphsPerCharacter.Resize( numberOfCharacters ); + mGlyphsPerCharacter.Resize(numberOfCharacters); glyphsPerCharacterBuffer = mGlyphsPerCharacter.Begin() + startIndex; } @@ -152,23 +148,23 @@ void VisualModel::CreateGlyphsPerCharacterTable( CharacterIndex startIndex, // The number of 'characters per glyph' equal to zero. Length zeroCharactersPerGlyph = 0u; - for( Vector::ConstIterator it = mCharactersPerGlyph.Begin() + startGlyphIndex, - endIt = mCharactersPerGlyph.End(); - ( it != endIt ) && ( traversedCharacters < numberOfCharacters ); - ++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) { *glyphsPerCharacterBuffer = 0u; @@ -186,106 +182,126 @@ void VisualModel::CreateGlyphsPerCharacterTable( CharacterIndex startIndex, } // If the glyphs per character buffer is updated, it needs to be inserted in the model. - if( updateCurrentBuffer ) + if(updateCurrentBuffer) { - mGlyphsPerCharacter.Insert( mGlyphsPerCharacter.Begin() + startIndex, - newGlyphsPerCharacter.Begin(), - newGlyphsPerCharacter.End() ); + 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 +Length VisualModel::GetTotalNumberOfLines() const +{ + return mLines.Size(); +} + +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.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs > glyphIndex ) && - ( lastGlyphIndex > line.glyphRun.glyphIndex ) ) + if((line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs > glyphIndex) && + (lastGlyphIndex > line.glyphRun.glyphIndex)) { firstLineFound = true; ++numberOfLines; } - else if( lastGlyphIndex <= line.glyphRun.glyphIndex ) + else if((line.glyphRunSecondHalf.glyphIndex + line.glyphRunSecondHalf.numberOfGlyphs > glyphIndex) && + (lastGlyphIndex > line.glyphRunSecondHalf.glyphIndex)) + { + firstLineFound = true; + ++numberOfLines; + } + 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 +LineIndex VisualModel::GetLineOfGlyph( GlyphIndex glyphIndex ) +{ + const CharacterIndex characterIndex = *(mGlyphsToCharacters.Begin() + glyphIndex); + return GetLineOfCharacter(characterIndex); +} + +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; @@ -295,16 +311,16 @@ LineIndex VisualModel::GetLineOfCharacter( CharacterIndex characterIndex ) return index; } -void VisualModel::GetUnderlineRuns( GlyphRun* underlineRuns, - UnderlineRunIndex index, - Length numberOfRuns ) const +void VisualModel::GetUnderlineRuns(UnderlinedGlyphRun* underlineRuns, + UnderlineRunIndex index, + Length numberOfRuns) const { - memcpy( underlineRuns, - mUnderlineRuns.Begin() + index, - numberOfRuns * sizeof( GlyphRun ) ); + memcpy(underlineRuns, + mUnderlineRuns.Begin() + index, + numberOfRuns * sizeof(UnderlinedGlyphRun)); } -void VisualModel::SetNaturalSize( const Vector2& size ) +void VisualModel::SetNaturalSize(const Vector2& size) { mNaturalSize = size; } @@ -314,7 +330,7 @@ const Vector2& VisualModel::GetNaturalSize() const return mNaturalSize; } -void VisualModel::SetLayoutSize( const Vector2& size ) +void VisualModel::SetLayoutSize(const Vector2& size) { mLayoutSize = size; } @@ -324,52 +340,137 @@ const Vector2& VisualModel::GetLayoutSize() const 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) { - mUnderlineColor = color; + mShadowBlurRadius = shadowBlurRadius; +} + +void VisualModel::SetUnderlineColor(const Vector4& color) +{ + mUnderlineColor = color; mUnderlineColorSet = true; } -void VisualModel::SetOutlineColor( const Vector4& color ) +void VisualModel::SetOutlineColor(const Vector4& color) { mOutlineColor = color; } -void VisualModel::SetUnderlineEnabled( bool enabled ) +void VisualModel::SetUnderlineEnabled(bool enabled) { mUnderlineEnabled = enabled; } -void VisualModel::SetUnderlineHeight( float height ) +void VisualModel::SetUnderlineHeight(float height) { mUnderlineHeight = height; } -void VisualModel::SetOutlineWidth( float width ) +void VisualModel::SetUnderlineType(Text::Underline::Type type) +{ + mUnderlineType = type; +} + +void VisualModel::SetDashedUnderlineWidth(float width) +{ + mDashedUnderlineWidth = width; +} + +void VisualModel::SetDashedUnderlineGap(float gap) +{ + mDashedUnderlineGap = gap; +} + +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; +} + +void VisualModel::SetStrikethroughColor(const Vector4& color) +{ + mStrikethroughColor = color; +} + +void VisualModel::SetStrikethroughEnabled(bool enabled) +{ + mStrikethroughEnabled = enabled; +} + +void VisualModel::SetStrikethroughHeight(float height) +{ + mStrikethroughHeight = height; +} + +void VisualModel::SetCharacterSpacing(float characterSpacing) +{ + mCharacterSpacing = characterSpacing; +} + const Vector4& VisualModel::GetTextColor() const { return mTextColor; @@ -385,6 +486,11 @@ const Vector4& VisualModel::GetShadowColor() const return mShadowColor; } +const float& VisualModel::GetShadowBlurRadius() const +{ + return mShadowBlurRadius; +} + const Vector4& VisualModel::GetUnderlineColor() const { return mUnderlineColor; @@ -405,21 +511,130 @@ float VisualModel::GetUnderlineHeight() const return mUnderlineHeight; } -float VisualModel::GetOutlineWidth() const +Text::Underline::Type VisualModel::GetUnderlineType() const +{ + return mUnderlineType; +} + +float VisualModel::GetDashedUnderlineWidth() const +{ + return mDashedUnderlineWidth; +} + +float VisualModel::GetDashedUnderlineGap() const +{ + return mDashedUnderlineGap; +} + +uint16_t VisualModel::GetOutlineWidth() const { return mOutlineWidth; } +const Vector4& VisualModel::GetBackgroundColor() const +{ + return mBackgroundColor; +} + +const float VisualModel::GetCharacterSpacing() const +{ + return mCharacterSpacing; +} + +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(); } +const Vector4& VisualModel::GetStrikethroughColor() const +{ + return mStrikethroughColor; +} + +bool VisualModel::IsStrikethroughEnabled() const +{ + return mStrikethroughEnabled; +} + +float VisualModel::GetStrikethroughHeight() const +{ + return mStrikethroughHeight; +} + +void VisualModel::GetStrikethroughRuns(StrikethroughGlyphRun* strikethroughRuns, + StrikethroughRunIndex index, + Length numberOfRuns) const +{ + memcpy(strikethroughRuns, + mStrikethroughRuns.Begin() + index, + numberOfRuns * sizeof(StrikethroughGlyphRun)); +} + +Length VisualModel::GetNumberOfStrikethroughRuns() const +{ + return mStrikethroughRuns.Count(); +} + +Length VisualModel::GetNumberOfCharacterSpacingGlyphRuns() const +{ + return mCharacterSpacingRuns.Count(); +} + +const Vector& VisualModel::GetCharacterSpacingGlyphRuns() const +{ + return mCharacterSpacingRuns; +} + void VisualModel::ClearCaches() { mCachedLineIndex = 0u; } +const Vector& VisualModel::GetGlyphsToCharacters() const +{ + return mGlyphsToCharacters; +} + VisualModel::~VisualModel() { } @@ -432,19 +647,37 @@ VisualModel::VisualModel() mGlyphsPerCharacter(), mGlyphPositions(), mLines(), - mTextColor( Color::BLACK ), - mShadowColor( Color::BLACK ), - mUnderlineColor( Color::BLACK ), - mOutlineColor( Color::WHITE ), + mTextColor(Color::BLACK), + mShadowColor(Color::BLACK), + mUnderlineColor(Color::BLACK), + mOutlineColor(Color::WHITE), + mBackgroundColor(Color::TRANSPARENT), + mStrikethroughColor(Color::BLACK), mControlSize(), mShadowOffset(), - mUnderlineHeight( 0.0f ), - mOutlineWidth( 0.0f ), + mUnderlineHeight(0.0f), + mStrikethroughHeight(0.0f), + mUnderlineType(Text::Underline::SOLID), + mDashedUnderlineWidth(2.0f), + mDashedUnderlineGap(1.0f), + mShadowBlurRadius(0.0f), + mOutlineWidth(0u), mNaturalSize(), mLayoutSize(), - mCachedLineIndex( 0u ), - mUnderlineEnabled( false ), - mUnderlineColorSet( false ) + mCachedLineIndex(0u), + mEllipsisPosition(DevelText::EllipsisPosition::END), + mStartIndexOfElidedGlyphs(0u), + mEndIndexOfElidedGlyphs(0u), + mFirstMiddleIndexOfElidedGlyphs(0u), + mSecondMiddleIndexOfElidedGlyphs(0u), + mTextElideEnabled(false), + mUnderlineEnabled(false), + mUnderlineColorSet(false), + mBackgroundEnabled(false), + mMarkupProcessorEnabled(false), + mStrikethroughEnabled(false), + mCharacterSpacing(0.0f) + { }