From: greynaga Date: Fri, 13 Oct 2017 14:00:35 +0000 (+0100) Subject: [dali_1.2.61] Merge branch 'devel/master' X-Git-Tag: dali_1.9.8~5^2~126 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=commitdiff_plain;h=1b78a757a60b1eb2d74204b96646bdda62cc8c1f;hp=410125f32fcd135226a2a0a668b2855ea9e17a69 [dali_1.2.61] Merge branch 'devel/master' Change-Id: I02d7ace3aa966803ff368b584fc59f23314c23e9 --- diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Markup.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Markup.cpp old mode 100644 new mode 100755 index 87db667..7007170 --- a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Markup.cpp +++ b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Markup.cpp @@ -166,6 +166,34 @@ namespace return true; } + /////////////////////////////////////////////////////////// + + + struct XHTMLEntityToUTF8Data + { + std::string description; + std::string xHTMLEntityString; + std::string expectedString; + }; + + bool XHTMLEntityToUTF8Test( const XHTMLEntityToUTF8Data& data ) + { + std::cout << " testing " << data.description << std::endl; + + Vector colorRuns; + Vector fontRuns; + MarkupProcessData markupProcessData( colorRuns, fontRuns ); + ProcessMarkupString( data.xHTMLEntityString, markupProcessData ); + + if( markupProcessData.markupProcessedText != data.expectedString ) + { + std::cout << " different output string : " << markupProcessData.markupProcessedText << ", expected : " << data.expectedString << " " << std::endl; + return false; + } + + return true; + } + } // namespace int UtcDaliTextTokenComparison(void) @@ -451,3 +479,54 @@ int UtcDaliTextVector2ToString(void) tet_result(TET_PASS); END_TEST; } + +int UtcDaliTextXHTMLEntityToUTF8(void) +{ + tet_infoline(" UtcDaliTextXHTMLEntityToUTF8"); + const XHTMLEntityToUTF8Data data[] = + { + { + "Text Without XHTML Entity", + "Checking XHTML Entitities", + "Checking XHTML Entitities" + }, + { + "Text With XHTML Entity in Numeric form", + "Checking Numeric Entitities & ' < > ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å æ Ç È É Ê Ë Ì Í Î Ï ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ý þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ σ τ υ φ χ ψ ω … € ← ↑ → ↓ ↔ ← → ∀ ∃ ∇ ∏ ∑ ∧ ∨ ∫ ≠ ≡ ⊕ ⊥ † ‡ • ", + "Checking Numeric Entitities & ' < > ¡ ¢ £ ¤ Â¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å æ Ç È É Ê Ë Ì Í Î Ï ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ý þ ß à á â ã ä Ã¥ æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ σ τ υ φ χ ψ ω … € ← ↑ → ↓ ↔ ← → ∀ ∃ ∇ ∏ ∑ ∧ ∨ ∫ ≠ ≡ ⊕ ⊥ † ‡ • " + }, + { + "Text With XHTML Named Entities", + "Checking Named Entitities & ' < > ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å æ Ç È É Ê Ë Ì Í Î Ï ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ý þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ σ τ υ φ χ ψ ω … € ← ↑ → ↓ ↔ ← → ∀ ∃ ∇ ∏ ∑ ∧ ∨ ∫ ≠ ≡ ⊕ ⊥ † ‡ • ", + "Checking Named Entitities & ' < > ¡ ¢ £ ¤ Â¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å æ Ç È É Ê Ë Ì Í Î Ï ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ý þ ß à á â ã ä Ã¥ æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ σ τ υ φ χ ψ ω … € ← ↑ → ↓ ↔ ← → ∀ ∃ ∇ ∏ ∑ ∧ ∨ ∫ ≠ ≡ ⊕ ⊥ † ‡ • " + }, + { + "Testing of < special character", + "Testing of < special character", + "Testing of " + }, + { + "Testing of & special character", + "Testing of & special character", + "Testing of " + }, + { + "Testing of & < > special character", + "Testing of \\& \\< \\> special character", + "Testing of & < > special character" + } + }; + const unsigned int numberOfTests = 6u; + + for( unsigned int index = 0u; index < numberOfTests; ++index ) + { + ToolkitTestApplication application; + if( !XHTMLEntityToUTF8Test( data[index] ) ) + { + tet_result(TET_FAIL); + } + } + + tet_result(TET_PASS); + END_TEST; +} diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp index c4bc01d..02439bc 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp @@ -85,6 +85,7 @@ void TestGlAbstraction::Initialize() mEnableDisableTrace.Reset(); mShaderTrace.Reset(); mStencilFunctionTrace.Reset(); + mScissorTrace.Reset(); mTextureTrace.Reset(); mTexParamaterTrace.Reset(); mDrawTrace.Reset(); diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h index 8408b10..b306c3e 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h @@ -949,6 +949,15 @@ public: mScissorParams.y = y; mScissorParams.width = width; mScissorParams.height = height; + + std::stringstream out; + out << x << ", " << y << ", " << width << ", " << height; + TraceCallStack::NamedParams namedParams; + namedParams["x"] = ToString( x ); + namedParams["y"] = ToString( y ); + namedParams["width"] = ToString( width ); + namedParams["height"] = ToString( height ); + mScissorTrace.PushCall( "Scissor", out.str(), namedParams ); } inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) @@ -1951,6 +1960,11 @@ public: // TEST FUNCTIONS inline void ResetStencilFunctionCallStack() { mStencilFunctionTrace.Reset(); } inline TraceCallStack& GetStencilFunctionTrace() { return mStencilFunctionTrace; } + //Methods for Scissor verification + inline void EnableScissorCallTrace(bool enable) { mScissorTrace.Enable(enable); } + inline void ResetScissorCallStack() { mScissorTrace.Reset(); } + inline TraceCallStack& GetScissorTrace() { return mScissorTrace; } + //Methods for Uniform function verification inline void EnableSetUniformCallTrace(bool enable) { mSetUniformTrace.Enable(enable); } inline void ResetSetUniformCallStack() { mSetUniformTrace.Reset(); } @@ -2189,6 +2203,7 @@ private: TraceCallStack mDrawTrace; TraceCallStack mDepthFunctionTrace; TraceCallStack mStencilFunctionTrace; + TraceCallStack mScissorTrace; TraceCallStack mSetUniformTrace; // Shaders & Uniforms diff --git a/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp index 5a958d4..13cf696 100644 --- a/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp +++ b/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp @@ -913,9 +913,14 @@ void TextLabel::SetUpAutoScrolling() mTextScroller = Text::TextScroller::New( *this ); } + // Calculate the actual gap before scrolling wraps. + int textPadding = std::max( controlSize.x - textNaturalSize.x, 0.0f ); + float wrapGap = std::max( mTextScroller->GetGap(), textPadding ); + Vector2 textureSize = textNaturalSize + Vector2(wrapGap, 0.0f); // Add the gap as a part of the texture + // Create a texture of the text for scrolling Text::TypesetterPtr typesetter = Text::Typesetter::New( mController->GetTextModel() ); - PixelData data = typesetter->Render( textNaturalSize, Text::Typesetter::RENDER_TEXT_AND_STYLES, true, Pixel::RGBA8888 ); // ignore the horizontal alignment + PixelData data = typesetter->Render( textureSize, Text::Typesetter::RENDER_TEXT_AND_STYLES, true, Pixel::RGBA8888 ); // ignore the horizontal alignment Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D, data.GetPixelFormat(), data.GetWidth(), @@ -928,11 +933,12 @@ void TextLabel::SetUpAutoScrolling() // Filter mode needs to be set to linear to produce better quality while scaling. Sampler sampler = Sampler::New(); sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR ); + sampler.SetWrapMode( Dali::WrapMode::DEFAULT, Dali::WrapMode::REPEAT, Dali::WrapMode::DEFAULT ); // Wrap the texture in the x direction textureSet.SetSampler( 0u, sampler ); // Set parameters for scrolling Renderer renderer = static_cast( GetImplementation( mVisual ) ).GetRenderer(); - mTextScroller->SetParameters( Self(), renderer, textureSet, controlSize, textNaturalSize, direction, mController->GetHorizontalAlignment(), mController->GetVerticalAlignment() ); + mTextScroller->SetParameters( Self(), renderer, textureSet, controlSize, textureSize, wrapGap, direction, mController->GetHorizontalAlignment(), mController->GetVerticalAlignment() ); } void TextLabel::ScrollingFinished() diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list old mode 100644 new mode 100755 index 6622d01..3fa035e --- a/dali-toolkit/internal/file.list +++ b/dali-toolkit/internal/file.list @@ -153,4 +153,5 @@ toolkit_src_files = \ $(toolkit_src_dir)/transition-effects/cube-transition-fold-effect-impl.cpp \ $(toolkit_src_dir)/transition-effects/cube-transition-wave-effect-impl.cpp \ $(toolkit_src_dir)/scripting/script-impl.cpp \ - $(toolkit_src_dir)/scripting/script-plugin-proxy.cpp + $(toolkit_src_dir)/scripting/script-plugin-proxy.cpp \ + $(toolkit_src_dir)/text/xhtml-entities.cpp diff --git a/dali-toolkit/internal/text/markup-processor.cpp b/dali-toolkit/internal/text/markup-processor.cpp old mode 100644 new mode 100755 index 6ea6352..5bbe5ad --- a/dali-toolkit/internal/text/markup-processor.cpp +++ b/dali-toolkit/internal/text/markup-processor.cpp @@ -18,11 +18,18 @@ // FILE HEADER #include +// EXTERNAL INCLUDES +#include // for ULONG_MAX +#include + // INTERNAL INCLUDES #include #include #include #include +#include + + namespace Dali { @@ -53,12 +60,26 @@ const char EQUAL = '='; const char QUOTATION_MARK = '\''; const char SLASH = '/'; const char BACK_SLASH = '\\'; +const char AMPERSAND = '&'; +const char HASH = '#'; +const char SEMI_COLON = ';'; +const char CHAR_ARRAY_END = '\0'; +const char HEX_CODE = 'x'; const char WHITE_SPACE = 0x20; // ASCII value of the white space. +// Range 1 0x0u < XHTML_DECIMAL_ENTITY_RANGE <= 0xD7FFu +// Range 2 0xE000u < XHTML_DECIMAL_ENTITY_RANGE <= 0xFFFDu +// Range 3 0x10000u < XHTML_DECIMAL_ENTITY_RANGE <= 0x10FFFFu +const unsigned long XHTML_DECIMAL_ENTITY_RANGE[] = { 0x0u, 0xD7FFu, 0xE000u, 0xFFFDu, 0x10000u, 0x10FFFFu }; + const unsigned int MAX_NUM_OF_ATTRIBUTES = 5u; ///< The font tag has the 'family', 'size' 'weight', 'width' and 'slant' attrubutes. const unsigned int DEFAULT_VECTOR_SIZE = 16u; ///< Default size of run vectors. +#if defined(DEBUG_ENABLED) +Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_MARKUP_PROCESSOR"); +#endif + /** * @brief Struct used to retrieve the style runs from the mark-up string. */ @@ -354,6 +375,88 @@ bool IsTag( const char*& markupStringBuffer, return isTag; } +/** + * @brief Returns length of XHTML entity by parsing the text. It also determines if it is XHTML entity or not. + * + * @param[in] markupStringBuffer The mark-up string buffer. It's a const iterator pointing the current character. + * @param[in] markupStringEndBuffer Pointing to end of mark-up string buffer. + * + * @return Length of markupText in case of XHTML entity otherwise return 0. + */ +unsigned int GetXHTMLEntityLength( const char*& markupStringBuffer, + const char* const markupStringEndBuffer ) +{ + char character = *markupStringBuffer; + if( AMPERSAND == character ) // '&' + { + // if the iterator is pointing to a '&' character, then check for ';' to find end to XHTML entity. + ++markupStringBuffer; + if( markupStringBuffer < markupStringEndBuffer ) + { + unsigned int len = 1u; + for( ; markupStringBuffer < markupStringEndBuffer ; ++markupStringBuffer ) + { + character = *markupStringBuffer; + ++len; + if( SEMI_COLON == character ) // ';' + { + // found end of XHTML entity + ++markupStringBuffer; + return len; + } + else if( ( AMPERSAND == character ) || ( BACK_SLASH == character ) || ( LESS_THAN == character )) + { + return 0; + } + } + } + } + return 0; +} + +/** + * @brief It parses a XHTML string which has hex/decimal entity and fill its corresponging utf-8 string. + * + * @param[in] markupText The mark-up text buffer. + * @param[out] utf-8 text Corresponding to markup Text + * + * @return true if string is successfully parsed otherwise false + */ +bool XHTMLNumericEntityToUtf8 ( const char* markupText, char* utf8 ) +{ + bool result = false; + + if( NULL != markupText ) + { + bool isHex = false; + + // check if hex or decimal entity + if( ( CHAR_ARRAY_END != *markupText ) && ( HEX_CODE == *markupText ) ) + { + isHex = true; + ++markupText; + } + + char* end = NULL; + unsigned long l = strtoul( markupText, &end, ( isHex ? 16 : 10 ) ); // l contains UTF-32 code in case of correct XHTML entity + + // check for valid XHTML numeric entities (between '#' or "#x" and ';') + if( ( l > 0 ) && ( l < ULONG_MAX ) && ( *end == SEMI_COLON ) ) // in case wrong XHTML entity is set eg. "abcdefs;" in that case *end will be 'a' + { + /* characters XML 1.1 permits */ + if( ( ( XHTML_DECIMAL_ENTITY_RANGE[0] < l ) && ( l <= XHTML_DECIMAL_ENTITY_RANGE[1] ) ) || + ( ( XHTML_DECIMAL_ENTITY_RANGE[2] <= l ) && ( l <= XHTML_DECIMAL_ENTITY_RANGE[3] ) ) || + ( ( XHTML_DECIMAL_ENTITY_RANGE[4] <= l ) && ( l <= XHTML_DECIMAL_ENTITY_RANGE[5] ) ) ) + { + // Convert UTF32 code to UTF8 + Utf32ToUtf8( reinterpret_cast( &l ), 1, reinterpret_cast( utf8 ) ); + result = true; + } + } + } + return result; +} + } // namespace void ProcessMarkupString( const std::string& markupString, MarkupProcessData& markupProcessData ) @@ -547,32 +650,84 @@ void ProcessMarkupString( const std::string& markupString, MarkupProcessData& ma } } // } // end if( IsTag() ) - else + else if( markupStringBuffer < markupStringEndBuffer ) { unsigned char character = *markupStringBuffer; + const char* markupBuffer = markupStringBuffer; + unsigned char count = GetUtf8Length( character ); + char utf8[8]; if( ( BACK_SLASH == character ) && ( markupStringBuffer + 1u < markupStringEndBuffer ) ) { - // Adding < or > special character. + // Adding < , > or & special character. const unsigned char nextCharacter = *( markupStringBuffer + 1u ); - if( ( LESS_THAN == nextCharacter ) || ( GREATER_THAN == nextCharacter ) ) + if( ( LESS_THAN == nextCharacter ) || ( GREATER_THAN == nextCharacter ) || ( AMPERSAND == nextCharacter ) ) { character = nextCharacter; ++markupStringBuffer; + + count = GetUtf8Length( character ); + markupBuffer = markupStringBuffer; } } + else // checking if conatins XHTML entity or not + { + const unsigned int len = GetXHTMLEntityLength( markupStringBuffer, markupStringEndBuffer); - const unsigned char numberOfBytes = GetUtf8Length( character ); + // Parse markupStringTxt if it contains XHTML Entity between '&' and ';' + if( len > 0 ) + { + char* entityCode = NULL; + bool result = false; + count = 0; - markupProcessData.markupProcessedText.push_back( character ); - for( unsigned char i = 1u; i < numberOfBytes; ++i ) - { - ++markupStringBuffer; - markupProcessData.markupProcessedText.push_back( *markupStringBuffer ); + // Checking if XHTML Numeric Entity + if( HASH == *( markupBuffer + 1u ) ) + { + entityCode = &utf8[0]; + // markupBuffer is currently pointing to '&'. By adding 2u to markupBuffer it will point to numeric string by skipping "&#' + result = XHTMLNumericEntityToUtf8( ( markupBuffer + 2u ), entityCode ); + } + else // Checking if XHTML Named Entity + { + entityCode = const_cast ( NamedEntityToUtf8( markupBuffer, len ) ); + result = ( entityCode != NULL ); + } + if ( result ) + { + markupBuffer = entityCode; //utf8 text assigned to markupBuffer + character = markupBuffer[0]; + } + else + { + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Not valid XHTML entity : (%.*s) \n", len, markupBuffer ); + markupBuffer = NULL; + } + } + else // in case string conatins Start of XHTML Entity('&') but not its end character(';') + { + if( character == AMPERSAND ) + { + markupBuffer = NULL; + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Not Well formed XHTML content \n" ); + } + } } - ++characterIndex; - ++markupStringBuffer; + if( markupBuffer != NULL ) + { + const unsigned char numberOfBytes = GetUtf8Length( character ); + markupProcessData.markupProcessedText.push_back( character ); + + for( unsigned char i = 1u; i < numberOfBytes; ++i ) + { + ++markupBuffer; + markupProcessData.markupProcessedText.push_back( *markupBuffer ); + } + + ++characterIndex; + markupStringBuffer += count; + } } } diff --git a/dali-toolkit/internal/text/text-scroller.cpp b/dali-toolkit/internal/text/text-scroller.cpp index ae65fd2..e85a2fd 100644 --- a/dali-toolkit/internal/text/text-scroller.cpp +++ b/dali-toolkit/internal/text/text-scroller.cpp @@ -43,7 +43,6 @@ const int MINIMUM_SCROLL_SPEED = 1; // Speed should be set by Property system. const char* VERTEX_SHADER_SCROLL = DALI_COMPOSE_SHADER( attribute mediump vec2 aPosition;\n varying highp vec2 vTexCoord;\n - varying highp float vRatio;\n uniform mediump vec3 uSize;\n uniform mediump float uDelta;\n uniform mediump vec2 uTextureSize;\n @@ -67,12 +66,9 @@ const char* VERTEX_SHADER_SCROLL = DALI_COMPOSE_SHADER( mediump vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy );\n mediump vec2 visualSize = mix( uSize.xy * size, size, offsetSizeMode.zw );\n \n - mediump float smallTextPadding = max( visualSize.x - uTextureSize.x, 0. );\n - mediump float gap = max( uGap, smallTextPadding );\n mediump float delta = floor ( uDelta ) + 0.5;\n - vTexCoord.x = ( delta + uHorizontalAlign * ( uTextureSize.x - visualSize.x ) + floor( aPosition.x * visualSize.x ) + 0.5 - gap * 0.5 ) / ( uTextureSize.x + gap ) + 0.5;\n + vTexCoord.x = ( delta + uHorizontalAlign * ( uTextureSize.x - visualSize.x - uGap ) + floor( aPosition.x * visualSize.x ) + 0.5 - uGap * 0.5 ) / uTextureSize.x + 0.5;\n vTexCoord.y = ( uVerticalAlign * ( uTextureSize.y - visualSize.y ) + floor( aPosition.y * visualSize.y ) + 0.5 ) / ( uTextureSize.y ) + 0.5;\n - vRatio = uTextureSize.x / ( uTextureSize.x + gap );\n \n mediump vec4 vertexPosition = vec4( floor( ( aPosition + anchorPoint ) * visualSize + ( visualOffset + origin ) * uSize.xy ), 0.0, 1.0 );\n mediump vec4 nonAlignedVertex = uViewMatrix * uModelMatrix * vertexPosition;\n @@ -84,18 +80,11 @@ const char* VERTEX_SHADER_SCROLL = DALI_COMPOSE_SHADER( const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER( varying highp vec2 vTexCoord;\n - varying highp float vRatio;\n uniform sampler2D sTexture;\n \n void main()\n {\n - highp vec2 texCoord;\n - texCoord.y = vTexCoord.y;\n - texCoord.x = fract( vTexCoord.x ) / vRatio;\n - if ( texCoord.x > 1.0 || texCoord.y > 1.0 )\n - discard;\n - \n - gl_FragColor = texture2D( sTexture, texCoord );\n + gl_FragColor = texture2D( sTexture, vTexCoord );\n }\n ); @@ -252,10 +241,10 @@ TextScroller::~TextScroller() { } -void TextScroller::SetParameters( Actor scrollingTextActor, Renderer renderer, TextureSet textureSet, const Size& controlSize, const Size& textNaturalSize, CharacterDirection direction, HorizontalAlignment::Type horizontalAlignment, VerticalAlignment::Type verticalAlignment ) +void TextScroller::SetParameters( Actor scrollingTextActor, Renderer renderer, TextureSet textureSet, const Size& controlSize, const Size& textureSize, const float wrapGap, CharacterDirection direction, HorizontalAlignment::Type horizontalAlignment, VerticalAlignment::Type verticalAlignment ) { - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextScroller::SetParameters controlSize[%f,%f] offscreenSize[%f,%f] direction[%d]\n", - controlSize.x, controlSize.y, textNaturalSize.x, textNaturalSize.y, direction ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextScroller::SetParameters controlSize[%f,%f] textureSize[%f,%f] direction[%d]\n", + controlSize.x, controlSize.y, textureSize.x, textureSize.y, direction ); mRenderer = renderer; @@ -288,19 +277,19 @@ void TextScroller::SetParameters( Actor scrollingTextActor, Renderer renderer, T mRenderer.SetShader( shader ); mRenderer.SetTextures( textureSet ); - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextScroller::SetParameters mWrapGap[%f]\n", mWrapGap ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextScroller::SetParameters wrapGap[%f]\n", wrapGap ); const float horizontalAlign = HORIZONTAL_ALIGNMENT_TABLE[ horizontalAlignment ][ direction ]; const float verticalAlign = VERTICAL_ALIGNMENT_TABLE[ verticalAlignment ]; DALI_LOG_INFO( gLogFilter, Debug::Verbose, "TextScroller::SetParameters horizontalAlign[%f], verticalAlign[%f]\n", horizontalAlign, verticalAlign ); - scrollingTextActor.RegisterProperty( "uTextureSize", textNaturalSize ); + scrollingTextActor.RegisterProperty( "uTextureSize", textureSize ); scrollingTextActor.RegisterProperty( "uHorizontalAlign", horizontalAlign ); scrollingTextActor.RegisterProperty( "uVerticalAlign", verticalAlign ); - scrollingTextActor.RegisterProperty( "uGap", mWrapGap ); + scrollingTextActor.RegisterProperty( "uGap", wrapGap ); mScrollDeltaIndex = scrollingTextActor.RegisterProperty( "uDelta", 0.0f ); - float scrollAmount = std::max( textNaturalSize.width + mWrapGap, controlSize.width ); + float scrollAmount = std::max( textureSize.width, controlSize.width ); float scrollDuration = scrollAmount / mScrollSpeed; if ( direction ) diff --git a/dali-toolkit/internal/text/text-scroller.h b/dali-toolkit/internal/text/text-scroller.h index f2203a7..a7a6410 100644 --- a/dali-toolkit/internal/text/text-scroller.h +++ b/dali-toolkit/internal/text/text-scroller.h @@ -65,12 +65,13 @@ public: * @param[in] renderer renderer to render the text * @param[in] textureSet texture of the text to be scrolled * @param[in] controlSize size of the control to scroll within - * @param[in] textNaturalSize natural size of the text + * @param[in] textureSize size of the texture + * @param[in] wrapGap The gap before scrolling wraps * @param[in] direction text direction true for right to left text * @param[in] horizontalAlignment horizontal alignment of the text * @param[in] verticalAlignment vertical alignment of the text */ - void SetParameters( Actor scrollingTextActor, Dali::Renderer renderer, TextureSet textureSet, const Size& controlSize, const Size& offScreenSize, CharacterDirection direction, HorizontalAlignment::Type horizontalAlignment, VerticalAlignment::Type verticalAlignment ); + void SetParameters( Actor scrollingTextActor, Dali::Renderer renderer, TextureSet textureSet, const Size& controlSize, const Size& textureSize, const float wrapGap, CharacterDirection direction, HorizontalAlignment::Type horizontalAlignment, VerticalAlignment::Type verticalAlignment ); /** * @brief Set the gap distance to elapse before the text wraps around diff --git a/dali-toolkit/internal/text/xhtml-entities.cpp b/dali-toolkit/internal/text/xhtml-entities.cpp new file mode 100755 index 0000000..3ee7215 --- /dev/null +++ b/dali-toolkit/internal/text/xhtml-entities.cpp @@ -0,0 +1,331 @@ +/* + * Copyright (c) 2017 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include // for strlen() + +// FILE HEADER +#include "xhtml-entities.h" + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Text +{ + +namespace +{ +/** + * Implementation of the XHTML Entity matching + */ +struct XHTMLEntityLookup +{ + const char* const entityName; // XHTML Named Entity string + const char* const entityCode; // Corresponding UTF-8 +}; + +/* table of html name entities supported in DALi + * + * these are stored as pair with Named entity as Key and + * its utf 8 as value + */ +const XHTMLEntityLookup XHTMLEntityLookupTable[] = + { + { ""\0" ,"\x22\0" }, + { "&\0" ,"\x26\0" }, + { "'\0" ,"\x27\0" }, + { "<\0" ,"\x3c\0" }, + { ">\0" ,"\x3e\0" }, + { " \0" ,"\xc2\xa0\0" }, + { "¡\0" ,"\xc2\xa1\0" }, + { "¢\0" ,"\xc2\xa2\0" }, + { "£\0" ,"\xc2\xa3\0" }, + { "¤\0" ,"\xc2\xa4\0" }, + { "¥\0" ,"\xc2\xa5\0" }, + { "¦\0" ,"\xc2\xa6\0" }, + { "§\0" ,"\xc2\xa7\0" }, + { "¨\0" ,"\xc2\xa8\0" }, + { "©\0" ,"\xc2\xa9\0" }, + { "ª\0" ,"\xc2\xaa\0" }, + { "«\0" ,"\xc2\xab\0" }, + { "¬\0" ,"\xc2\xac\0" }, + { "­\0" ,"\xc2\xad\0" }, + { "®\0" ,"\xc2\xae\0" }, + { "¯\0" ,"\xc2\xaf\0" }, + { "°\0" ,"\xc2\xb0\0" }, + { "±\0" ,"\xc2\xb1\0" }, + { "²\0" ,"\xc2\xb2\0" }, + { "³\0" ,"\xc2\xb3\0" }, + { "´\0" ,"\xc2\xb4\0" }, + { "µ\0" ,"\xc2\xb5\0" }, + { "¶\0" ,"\xc2\xb6\0" }, + { "·\0" ,"\xc2\xb7\0" }, + { "¸\0" ,"\xc2\xb8\0" }, + { "¹\0" ,"\xc2\xb9\0" }, + { "º\0" ,"\xc2\xba\0" }, + { "»\0" ,"\xc2\xbb\0" }, + { "¼\0" ,"\xc2\xbc\0" }, + { "½\0" ,"\xc2\xbd\0" }, + { "¾\0" ,"\xc2\xbe\0" }, + { "¿\0" ,"\xc2\xbf\0" }, + { "À\0" ,"\xc3\x80\0" }, + { "Á\0" ,"\xc3\x81\0" }, + { "Â\0" ,"\xc3\x82\0" }, + { "Ã\0" ,"\xc3\x83\0" }, + { "Ä\0" ,"\xc3\x84\0" }, + { "Å\0" ,"\xc3\x85\0" }, + { "Æ\0" ,"\xc3\x86\0" }, + { "Ç\0" ,"\xc3\x87\0" }, + { "È\0" ,"\xc3\x88\0" }, + { "É\0" ,"\xc3\x89\0" }, + { "Ê\0" ,"\xc3\x8a\0" }, + { "Ë\0" ,"\xc3\x8b\0" }, + { "Ì\0" ,"\xc3\x8c\0" }, + { "Í\0" ,"\xc3\x8d\0" }, + { "Î\0" ,"\xc3\x8e\0" }, + { "Ï\0" ,"\xc3\x8f\0" }, + { "Ð\0" ,"\xc3\x90\0" }, + { "Ñ\0" ,"\xc3\x91\0" }, + { "Ò\0" ,"\xc3\x92\0" }, + { "Ó\0" ,"\xc3\x93\0" }, + { "Ô\0" ,"\xc3\x94\0" }, + { "Õ\0" ,"\xc3\x95\0" }, + { "Ö\0" ,"\xc3\x96\0" }, + { "×\0" ,"\xc3\x97\0" }, + { "Ø\0" ,"\xc3\x98\0" }, + { "Ù\0" ,"\xc3\x99\0" }, + { "Ú\0" ,"\xc3\x9a\0" }, + { "Û\0" ,"\xc3\x9b\0" }, + { "Ü\0" ,"\xc3\x9c\0" }, + { "Ý\0" ,"\xc3\x9d\0" }, + { "Þ\0" ,"\xc3\x9e\0" }, + { "ß\0" ,"\xc3\x9f\0" }, + { "à\0" ,"\xc3\xa0\0" }, + { "á\0" ,"\xc3\xa1\0" }, + { "â\0" ,"\xc3\xa2\0" }, + { "ã\0" ,"\xc3\xa3\0" }, + { "ä\0" ,"\xc3\xa4\0" }, + { "å\0" ,"\xc3\xa5\0" }, + { "æ\0" ,"\xc3\xa6\0" }, + { "ç\0" ,"\xc3\xa7\0" }, + { "è\0" ,"\xc3\xa8\0" }, + { "é\0" ,"\xc3\xa9\0" }, + { "ê\0" ,"\xc3\xaa\0" }, + { "ë\0" ,"\xc3\xab\0" }, + { "ì\0" ,"\xc3\xac\0" }, + { "í\0" ,"\xc3\xad\0" }, + { "î\0" ,"\xc3\xae\0" }, + { "ï\0" ,"\xc3\xaf\0" }, + { "ð\0" ,"\xc3\xb0\0" }, + { "ñ\0" ,"\xc3\xb1\0" }, + { "ò\0" ,"\xc3\xb2\0" }, + { "ó\0" ,"\xc3\xb3\0" }, + { "ô\0" ,"\xc3\xb4\0" }, + { "õ\0" ,"\xc3\xb5\0" }, + { "ö\0" ,"\xc3\xb6\0" }, + { "÷\0" ,"\xc3\xb7\0" }, + { "ø\0" ,"\xc3\xb8\0" }, + { "ù\0" ,"\xc3\xb9\0" }, + { "ú\0" ,"\xc3\xba\0" }, + { "û\0" ,"\xc3\xbb\0" }, + { "ü\0" ,"\xc3\xbc\0" }, + { "ý\0" ,"\xc3\xbd\0" }, + { "þ\0" ,"\xc3\xbe\0" }, + { "ÿ\0" ,"\xc3\xbf\0" }, + { "Œ\0" ,"\xc5\x92\0" }, + { "œ\0" ,"\xc5\x93\0" }, + { "Š\0" ,"\xc5\xa0\0" }, + { "š\0" ,"\xc5\xa1\0" }, + { "Ÿ\0" ,"\xc5\xb8\0" }, + { "ƒ\0" ,"\xc6\x92\0" }, + { "ˆ\0" ,"\xcb\x86\0" }, + { "˜\0" ,"\xcb\x9c\0" }, + { "Α\0" ,"\xce\x91\0" }, + { "Β\0" ,"\xce\x92\0" }, + { "Γ\0" ,"\xce\x93\0" }, + { "Δ\0" ,"\xce\x94\0" }, + { "Ε\0" ,"\xce\x95\0" }, + { "Ζ\0" ,"\xce\x96\0" }, + { "Η\0" ,"\xce\x97\0" }, + { "Θ\0" ,"\xce\x98\0" }, + { "Ι\0" ,"\xce\x99\0" }, + { "Κ\0" ,"\xce\x9a\0" }, + { "Λ\0" ,"\xce\x9b\0" }, + { "Μ\0" ,"\xce\x9c\0" }, + { "Ν\0" ,"\xce\x9d\0" }, + { "Ξ\0" ,"\xce\x9e\0" }, + { "Ο\0" ,"\xce\x9f\0" }, + { "Π\0" ,"\xce\xa0\0" }, + { "Ρ\0" ,"\xce\xa1\0" }, + { "Σ\0" ,"\xce\xa3\0" }, + { "Τ\0" ,"\xce\xa4\0" }, + { "Υ\0" ,"\xce\xa5\0" }, + { "Φ\0" ,"\xce\xa6\0" }, + { "Χ\0" ,"\xce\xa7\0" }, + { "Ψ\0" ,"\xce\xa8\0" }, + { "Ω\0" ,"\xce\xa9\0" }, + { "α\0" ,"\xce\xb1\0" }, + { "β\0" ,"\xce\xb2\0" }, + { "γ\0" ,"\xce\xb3\0" }, + { "δ\0" ,"\xce\xb4\0" }, + { "ε\0" ,"\xce\xb5\0" }, + { "ζ\0" ,"\xce\xb6\0" }, + { "η\0" ,"\xce\xb7\0" }, + { "θ\0" ,"\xce\xb8\0" }, + { "ι\0" ,"\xce\xb9\0" }, + { "κ\0" ,"\xce\xba\0" }, + { "λ\0" ,"\xce\xbb\0" }, + { "μ\0" ,"\xce\xbc\0" }, + { "ν\0" ,"\xce\xbd\0" }, + { "ξ\0" ,"\xce\xbe\0" }, + { "ο\0" ,"\xce\xbf\0" }, + { "π\0" ,"\xcf\x80\0" }, + { "ρ\0" ,"\xcf\x81\0" }, + { "ς\0" ,"\xcf\x82\0" }, + { "σ\0" ,"\xcf\x83\0" }, + { "τ\0" ,"\xcf\x84\0" }, + { "υ\0" ,"\xcf\x85\0" }, + { "φ\0" ,"\xcf\x86\0" }, + { "χ\0" ,"\xcf\x87\0" }, + { "ψ\0" ,"\xcf\x88\0" }, + { "ω\0" ,"\xcf\x89\0" }, + { "ϑ\0","\xcf\x91\0" }, + { "ϒ\0" ,"\xcf\x92\0" }, + { "ϖ\0" ,"\xcf\x96\0" }, + { " \0" ,"\xe2\x80\x82\0" }, + { " \0" ,"\xe2\x80\x83\0" }, + { " \0" ,"\xe2\x80\x89\0" }, + { "‌\0" ,"\xe2\x80\x8c\0" }, + { "‍\0" ,"\xe2\x80\x8d\0" }, + { "‎\0" ,"\xe2\x80\x8e\0" }, + { "‏\0" ,"\xe2\x80\x8f\0" }, + { "–\0" ,"\xe2\x80\x93\0" }, + { "—\0" ,"\xe2\x80\x94\0" }, + { "‘\0" ,"\xe2\x80\x98\0" }, + { "’\0" ,"\xe2\x80\x99\0" }, + { "‚\0" ,"\xe2\x80\x9a\0" }, + { "“\0" ,"\xe2\x80\x9c\0" }, + { "”\0" ,"\xe2\x80\x9d\0" }, + { "„\0" ,"\xe2\x80\x9e\0" }, + { "†\0" ,"\xe2\x80\xa0\0" }, + { "‡\0" ,"\xe2\x80\xa1\0" }, + { "•\0" ,"\xe2\x80\xa2\0" }, + { "…\0" ,"\xe2\x80\xa6\0" }, + { "‰\0" ,"\xe2\x80\xb0\0" }, + { "′\0" ,"\xe2\x80\xb2\0" }, + { "″\0" ,"\xe2\x80\xb3\0" }, + { "‹\0" ,"\xe2\x80\xb9\0" }, + { "›\0" ,"\xe2\x80\xba\0" }, + { "‾\0" ,"\xe2\x80\xbe\0" }, + { "⁄\0" ,"\xe2\x81\x84\0" }, + { "€\0" ,"\xe2\x82\xac\0" }, + { "ℑ\0" ,"\xe2\x84\x91\0" }, + { "℘\0" ,"\xe2\x84\x98\0" }, + { "ℜ\0" ,"\xe2\x84\x9c\0" }, + { "™\0" ,"\xe2\x84\xa2\0" }, + { "ℵ\0" ,"\xe2\x84\xb5\0" }, + { "←\0" ,"\xe2\x86\x90\0" }, + { "↑\0" ,"\xe2\x86\x91\0" }, + { "→\0" ,"\xe2\x86\x92\0" }, + { "↓\0" ,"\xe2\x86\x93\0" }, + { "↔\0" ,"\xe2\x86\x94\0" }, + { "↵\0" ,"\xe2\x86\xb5\0" }, + { "⇐\0" ,"\xe2\x87\x90\0" }, + { "⇑\0" ,"\xe2\x87\x91\0" }, + { "⇒\0" ,"\xe2\x87\x92\0" }, + { "⇓\0" ,"\xe2\x87\x93\0" }, + { "⇔\0" ,"\xe2\x87\x94\0" }, + { "∀\0" ,"\xe2\x88\x80\0" }, + { "∂\0" ,"\xe2\x88\x82\0" }, + { "∃\0" ,"\xe2\x88\x83\0" }, + { "∅\0" ,"\xe2\x88\x85\0" }, + { "∇\0" ,"\xe2\x88\x87\0" }, + { "∈\0" ,"\xe2\x88\x88\0" }, + { "∉\0" ,"\xe2\x88\x89\0" }, + { "∋\0" ,"\xe2\x88\x8b\0" }, + { "∏\0" ,"\xe2\x88\x8f\0" }, + { "∑\0" ,"\xe2\x88\x91\0" }, + { "−\0" ,"\xe2\x88\x92\0" }, + { "∗\0" ,"\xe2\x88\x97\0" }, + { "√\0" ,"\xe2\x88\x9a\0" }, + { "∝\0" ,"\xe2\x88\x9d\0" }, + { "∞\0" ,"\xe2\x88\x9e\0" }, + { "∠\0" ,"\xe2\x88\xa0\0" }, + { "∧\0" ,"\xe2\x88\xa7\0" }, + { "∨\0" ,"\xe2\x88\xa8\0" }, + { "∩\0" ,"\xe2\x88\xa9\0" }, + { "∪\0" ,"\xe2\x88\xaa\0" }, + { "∫\0" ,"\xe2\x88\xab\0" }, + { "∴\0" ,"\xe2\x88\xb4\0" }, + { "∼\0" ,"\xe2\x88\xbc\0" }, + { "≅\0" ,"\xe2\x89\x85\0" }, + { "≈\0" ,"\xe2\x89\x88\0" }, + { "≠\0" ,"\xe2\x89\xa0\0" }, + { "≡\0" ,"\xe2\x89\xa1\0" }, + { "≤\0" ,"\xe2\x89\xa4\0" }, + { "≥\0" ,"\xe2\x89\xa5\0" }, + { "⊂\0" ,"\xe2\x8a\x82\0" }, + { "⊃\0" ,"\xe2\x8a\x83\0" }, + { "⊄\0" ,"\xe2\x8a\x84\0" }, + { "⊆\0" ,"\xe2\x8a\x86\0" }, + { "⊇\0" ,"\xe2\x8a\x87\0" }, + { "⊕\0" ,"\xe2\x8a\x95\0" }, + { "⊗\0" ,"\xe2\x8a\x97\0" }, + { "⊥\0" ,"\xe2\x8a\xa5\0" }, + { "⋅\0" ,"\xe2\x8b\x85\0" }, + { "⌈\0" ,"\xe2\x8c\x88\0" }, + { "⌉\0" ,"\xe2\x8c\x89\0" }, + { "⌊\0" ,"\xe2\x8c\x8a\0" }, + { "⌋\0" ,"\xe2\x8c\x8b\0" }, + { "◊\0" ,"\xe2\x97\x8a\0" }, + { "♠\0" ,"\xe2\x99\xa0\0" }, + { "♣\0" ,"\xe2\x99\xa3\0" }, + { "♥\0" ,"\xe2\x99\xa5\0" }, + { "♦\0" ,"\xe2\x99\xa6\0" }, + { "⟨\0" ,"\xe2\x9f\xa8\0" }, + { "⟩\0" ,"\xe2\x9f\xa9\0" } +}; + +const std::size_t XHTMLENTITY_LOOKUP_COUNT = (sizeof( XHTMLEntityLookupTable))/ (sizeof(XHTMLEntityLookup)); + +} // unnamed namespace + +const char* const NamedEntityToUtf8( const char* const markupText, unsigned int len ) +{ + // finding if given XHTML named entity is supported or not + for( size_t i = 0; i < XHTMLENTITY_LOOKUP_COUNT ; ++i ) + { + unsigned int entityLen = strlen(XHTMLEntityLookupTable[i].entityName); + if( len == entityLen ) + { + if( strncmp( markupText, XHTMLEntityLookupTable[i].entityName, len ) == 0 ) // if named Entity found in table + { + return XHTMLEntityLookupTable[i].entityCode; + } + } + } + return NULL; +} + +} // namespace Text + +} // namespace Toolkit + +} // namespace Dali diff --git a/dali-toolkit/internal/text/xhtml-entities.h b/dali-toolkit/internal/text/xhtml-entities.h new file mode 100755 index 0000000..c09d5cd --- /dev/null +++ b/dali-toolkit/internal/text/xhtml-entities.h @@ -0,0 +1,45 @@ +#ifndef DALI_TOOLKIT_TEXT_XHTML_ENTITIES_H +#define DALI_TOOLKIT_TEXT_XHTML_ENTITIES_H + +/* + * Copyright (c) 2017 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +namespace Dali +{ + +namespace Toolkit +{ + +namespace Text +{ +/** + * @brief Retrieves UTF8 entity code for corresponding XHTML named Entity. + * + * @param[in] markupText The XHTML named entity. + * @param[int] len Length of markupText. + * + * @return pointer to UTF8 entity code if namedEntity found in table otherwise NULL + */ +const char* const NamedEntityToUtf8( const char* const markupText, unsigned int len ); + +} // namespace Text + +} // namespace Toolkit + +} // namespace Dali + +#endif // DALI_TOOLKIT_TEXT_XHTML_ENTITIES_H diff --git a/dali-toolkit/internal/visuals/text/text-visual.cpp b/dali-toolkit/internal/visuals/text/text-visual.cpp index e8c97f6..6c35875 100755 --- a/dali-toolkit/internal/visuals/text/text-visual.cpp +++ b/dali-toolkit/internal/visuals/text/text-visual.cpp @@ -657,6 +657,7 @@ void TextVisual::UpdateRenderer() mImpl->mRenderer.RegisterProperty( "uHasMultipleTextColors", static_cast( hasMultipleTextColors ) ); mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON); + mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true ); //Register transform properties mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT ); diff --git a/dali-toolkit/public-api/controls/control-impl.cpp b/dali-toolkit/public-api/controls/control-impl.cpp index 1fb9f44..68fd55a 100644 --- a/dali-toolkit/public-api/controls/control-impl.cpp +++ b/dali-toolkit/public-api/controls/control-impl.cpp @@ -60,13 +60,30 @@ namespace Debug::Filter* gLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_CONTROL_VISUALS"); #endif -DALI_ENUM_TO_STRING_TABLE_BEGIN( CLIPPING_MODE ) -DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, DISABLED ) -DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, CLIP_CHILDREN ) -DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE ) +/** + * @brief Creates a clipping renderer if required. + * (EG. If no renders exist and clipping is enabled). + * @param[in] controlImpl The control implementation. + */ +void CreateClippingRenderer( Control& controlImpl ) +{ + // We want to add a transparent background if we do not have one for clipping. + Actor self( controlImpl.Self() ); + int clippingMode = ClippingMode::DISABLED; + if( self.GetProperty( Actor::Property::CLIPPING_MODE ).Get( clippingMode ) ) + { + Internal::Control::Impl& controlDataImpl = Internal::Control::Impl::Get( controlImpl ); -} // unnamed namespace + if( ( clippingMode == ClippingMode::CLIP_CHILDREN ) && + controlDataImpl.mVisuals.Empty() && + ( self.GetRendererCount() == 0u ) ) + { + controlImpl.SetBackgroundColor( Color::TRANSPARENT ); + } + } +} +} // unnamed namespace Toolkit::Control Control::New() @@ -498,21 +515,8 @@ void Control::OnStageConnection( int depth ) } } - if( mImpl->mVisuals.Empty() && ! self.GetRendererCount() ) - { - Property::Value clippingValue = self.GetProperty( Actor::Property::CLIPPING_MODE ); - int clippingMode = ClippingMode::DISABLED; - if( clippingValue.Get( clippingMode ) ) - { - // Add a transparent background if we do not have any renderers or visuals so we clip our children - - if( clippingMode == ClippingMode::CLIP_CHILDREN ) - { - // Create a transparent background visual which will also get staged. - SetBackgroundColor( Color::TRANSPARENT ); - } - } - } + // The clipping renderer is only created if required. + CreateClippingRenderer( *this ); } void Control::OnStageDisconnection() @@ -544,24 +548,12 @@ void Control::OnChildRemove(Actor& child) void Control::OnPropertySet( Property::Index index, Property::Value propertyValue ) { - Actor self( Self() ); - if( index == Actor::Property::CLIPPING_MODE ) + // If the clipping mode has been set, we may need to create a renderer. + // Only do this if we are already on-stage as the OnStageConnection will handle the off-stage clipping controls. + if( ( index == Actor::Property::CLIPPING_MODE ) && Self().OnStage() ) { - // Only set the background if we're already on the stage and have no renderers or visuals - - if( mImpl->mVisuals.Empty() && ! self.GetRendererCount() && self.OnStage() ) - { - ClippingMode::Type clippingMode = ClippingMode::DISABLED; - if( Scripting::GetEnumerationProperty< ClippingMode::Type >( propertyValue, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, clippingMode ) ) - { - // Add a transparent background if we do not have one so we clip children - - if( clippingMode == ClippingMode::CLIP_CHILDREN ) - { - SetBackgroundColor( Color::TRANSPARENT ); - } - } - } + // Note: This method will handle whether creation of the renderer is required. + CreateClippingRenderer( *this ); } } diff --git a/dali-toolkit/public-api/dali-toolkit-version.cpp b/dali-toolkit/public-api/dali-toolkit-version.cpp index b057950..82e5b62 100644 --- a/dali-toolkit/public-api/dali-toolkit-version.cpp +++ b/dali-toolkit/public-api/dali-toolkit-version.cpp @@ -31,7 +31,7 @@ namespace Toolkit const unsigned int TOOLKIT_MAJOR_VERSION = 1; const unsigned int TOOLKIT_MINOR_VERSION = 2; -const unsigned int TOOLKIT_MICRO_VERSION = 60; +const unsigned int TOOLKIT_MICRO_VERSION = 61; const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__; #ifdef DEBUG_ENABLED diff --git a/docs/content/images/text-controls/SpecialCharacter1.png b/docs/content/images/text-controls/SpecialCharacter1.png new file mode 100755 index 0000000..6515a8b Binary files /dev/null and b/docs/content/images/text-controls/SpecialCharacter1.png differ diff --git a/docs/content/images/text-controls/SpecialCharacters.png b/docs/content/images/text-controls/SpecialCharacters.png new file mode 100755 index 0000000..0e9ecca Binary files /dev/null and b/docs/content/images/text-controls/SpecialCharacters.png differ diff --git a/docs/content/images/text-controls/XHTML_entity.png b/docs/content/images/text-controls/XHTML_entity.png new file mode 100755 index 0000000..b656a5f Binary files /dev/null and b/docs/content/images/text-controls/XHTML_entity.png differ diff --git a/docs/content/shared-javascript-and-cpp-documentation/markup-style.md b/docs/content/shared-javascript-and-cpp-documentation/markup-style.md old mode 100644 new mode 100755 index 1893273..5697959 --- a/docs/content/shared-javascript-and-cpp-documentation/markup-style.md +++ b/docs/content/shared-javascript-and-cpp-documentation/markup-style.md @@ -126,4 +126,56 @@ field.SetProperty( TextLabel::Property::TEXT, " : Greater Than. It means end of tag. +- & : Ampersand. It means beginning of XHTML Entity. + +> "&" usage in markup style changed from Tizen 4.0. +"To display special character needs as regular, prepend it with two backslashes in the string." + +Below are some examples + +~~~{.cpp} +// C++ ( Wrong usage to print text "Testing of < special character" ) +field.SetProperty( TextLabel::Property::TEXT, "Testing of < special character" ); +~~~ + +![ ](SpecialCharacter1.png) + +~~~{.cpp} +// C++ ( Wrong usage to print text "Testing of & special character" ) +field.SetProperty( TextLabel::Property::TEXT, "Testing of & special character" ); +~~~ + +![ ](SpecialCharacter1.png) + +~~~{.cpp} +// C++ ( Correct usage to print text "Testing of & < > special characters" ) +field.SetProperty( TextLabel::Property::TEXT, "Testing of \\& \\< \\> special characters" ); +~~~ + +![ ](SpecialCharacters.png) + */ diff --git a/packaging/dali-toolkit.spec b/packaging/dali-toolkit.spec index 536ceaa..9663c7a 100644 --- a/packaging/dali-toolkit.spec +++ b/packaging/dali-toolkit.spec @@ -1,6 +1,6 @@ Name: dali-toolkit Summary: Dali 3D engine Toolkit -Version: 1.2.60 +Version: 1.2.61 Release: 1 Group: System/Libraries License: Apache-2.0 and BSD-3-Clause and MIT