X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fvisual-base-impl.cpp;h=064b13dc8815207f32df7883ce3bb771dbb3562d;hb=88af55c0bf70653347b6918a83bc9a9ee5972e24;hp=701da0ee93a0d26059a6913d0046992b625e4920;hpb=8747c12ce2d714ea694401ee435e78de1fd0653e;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/visuals/visual-base-impl.cpp b/dali-toolkit/internal/visuals/visual-base-impl.cpp index 701da0e..953e23e 100644 --- a/dali-toolkit/internal/visuals/visual-base-impl.cpp +++ b/dali-toolkit/internal/visuals/visual-base-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. @@ -19,34 +19,106 @@ #include "visual-base-impl.h" // EXTERNAL HEADER -#include -#include +#include +#include +#include #include +#include //INTERNAL HEARDER +#include #include +#include #include #include +#include +#include +#include namespace { #if defined(DEBUG_ENABLED) -Debug::Filter* gVisualBaseLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VISUAL_BASE" ); +Debug::Filter* gVisualBaseLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VISUAL_BASE"); #endif -} + +// visual string constants contains OFFSET_SIZE_MODE instead +const char* const OFFSET_POLICY("offsetPolicy"); +const char* const SIZE_POLICY("sizePolicy"); + +} // namespace namespace Dali { - namespace Toolkit { - namespace Internal { +namespace +{ +DALI_ENUM_TO_STRING_TABLE_BEGIN(VISUAL_FITTING_MODE) + DALI_ENUM_TO_STRING_WITH_SCOPE(Visual::FittingMode, FIT_KEEP_ASPECT_RATIO) + DALI_ENUM_TO_STRING_WITH_SCOPE(Visual::FittingMode, FILL) + DALI_ENUM_TO_STRING_WITH_SCOPE(Visual::FittingMode, OVER_FIT_KEEP_ASPECT_RATIO) + DALI_ENUM_TO_STRING_WITH_SCOPE(Visual::FittingMode, CENTER) + DALI_ENUM_TO_STRING_WITH_SCOPE(Visual::FittingMode, FIT_WIDTH) + DALI_ENUM_TO_STRING_WITH_SCOPE(Visual::FittingMode, FIT_HEIGHT) +DALI_ENUM_TO_STRING_TABLE_END(VISUAL_FITTING_MODE) + +/** + * @brief Check whether this visual type can use corner radius feature or not. + * @param type VisualType that want to checkup + * @return true if type can use corner radius feature. + */ +static bool IsTypeAvailableForCornerRadius(Toolkit::Visual::Type type) +{ + switch(static_cast(type)) + { + case Toolkit::Visual::Type::COLOR: + case Toolkit::Visual::Type::GRADIENT: + case Toolkit::Visual::Type::IMAGE: + case Toolkit::Visual::Type::SVG: + case Toolkit::Visual::Type::ANIMATED_IMAGE: + case Toolkit::DevelVisual::Type::ANIMATED_VECTOR_IMAGE: + { + return true; + } + default: + { + return false; + } + } +} + +/** + * @brief Check whether this visual type can use borderline feature or not. + * @param type VisualType that want to checkup + * @return true if type can use borderline feature. + */ +static bool IsTypeAvailableForBorderline(Toolkit::Visual::Type type) +{ + switch(static_cast(type)) + { + case Toolkit::Visual::Type::COLOR: + case Toolkit::Visual::Type::GRADIENT: + case Toolkit::Visual::Type::IMAGE: + case Toolkit::Visual::Type::SVG: + case Toolkit::Visual::Type::ANIMATED_IMAGE: + case Toolkit::DevelVisual::Type::ANIMATED_VECTOR_IMAGE: + { + return true; + } + default: + { + return false; + } + } +} + +} // namespace -Visual::Base::Base( VisualFactoryCache& factoryCache ) -: mImpl( new Impl() ), - mFactoryCache( factoryCache ) +Visual::Base::Base(VisualFactoryCache& factoryCache, FittingMode fittingMode, Toolkit::Visual::Type type) +: mImpl(new Impl(fittingMode, type)), + mFactoryCache(factoryCache) { } @@ -55,215 +127,513 @@ Visual::Base::~Base() delete mImpl; } -void Visual::Base::SetCustomShader( const Property::Map& shaderMap ) +void Visual::Base::Initialize() { - if( mImpl->mCustomShader ) + // The Renderer should be created inside derived class here. + OnInitialize(); + + if(mImpl->mRenderer) { - mImpl->mCustomShader->SetPropertyMap( shaderMap ); + RegisterMixColor(); + + if(IsRoundedCornerRequired()) + { + mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); + mImpl->mRenderer.RegisterUniqueProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); + + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); + } + if(IsBorderlineRequired()) + { + mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); + mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL); + } + } +} + +void Visual::Base::SetCustomShader(const Property::Map& shaderMap) +{ + if(mImpl->mCustomShader) + { + mImpl->mCustomShader->SetPropertyMap(shaderMap); } else { - mImpl->mCustomShader = new Impl::CustomShader( shaderMap ); + mImpl->mCustomShader = new Impl::CustomShader(shaderMap); } + + // Let derived class know + UpdateShader(); } -void Visual::Base::SetProperties( const Property::Map& propertyMap ) +void Visual::Base::SetProperties(const Property::Map& propertyMap) { - for( size_t i = 0; i < propertyMap.Count(); ++i ) + bool needUpdateShader = false; + for(size_t i = 0; i < propertyMap.Count(); ++i) { - const KeyValuePair& pair = propertyMap.GetKeyValue( i ); - const Property::Key& key = pair.first; + const KeyValuePair& pair = propertyMap.GetKeyValue(i); + const Property::Key& key = pair.first; const Property::Value& value = pair.second; Property::Key matchKey = key; - if( matchKey.type == Property::Key::STRING ) + if(matchKey.type == Property::Key::STRING) { - if( matchKey == CUSTOM_SHADER ) + if(matchKey == CUSTOM_SHADER) + { + matchKey = Property::Key(Toolkit::Visual::Property::SHADER); + } + else if(matchKey == TRANSFORM) + { + matchKey = Property::Key(Toolkit::Visual::Property::TRANSFORM); + } + else if(matchKey == PREMULTIPLIED_ALPHA) + { + matchKey = Property::Key(Toolkit::Visual::Property::PREMULTIPLIED_ALPHA); + } + else if(matchKey == MIX_COLOR) + { + matchKey = Property::Key(Toolkit::Visual::Property::MIX_COLOR); + } + else if(matchKey == OPACITY) + { + matchKey = Property::Key(Toolkit::Visual::Property::OPACITY); + } + else if(matchKey == VISUAL_FITTING_MODE) + { + matchKey = Property::Key(Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE); + } + else if(matchKey == BORDERLINE_WIDTH) { - matchKey = Property::Key( DevelVisual::Property::SHADER ); + matchKey = Property::Key(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH); } - else if( matchKey == TRANSFORM ) + else if(matchKey == BORDERLINE_COLOR) { - matchKey = Property::Key( DevelVisual::Property::TRANSFORM ); + matchKey = Property::Key(Toolkit::DevelVisual::Property::BORDERLINE_COLOR); } - else if( matchKey == PREMULTIPLIED_ALPHA ) + else if(matchKey == BORDERLINE_OFFSET) { - matchKey = Property::Key( DevelVisual::Property::PREMULTIPLIED_ALPHA ); + matchKey = Property::Key(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET); } - else if( matchKey == MIX_COLOR ) + else if(matchKey == CORNER_RADIUS) { - matchKey = Property::Key( DevelVisual::Property::MIX_COLOR ); + matchKey = Property::Key(Toolkit::DevelVisual::Property::CORNER_RADIUS); + } + else if(matchKey == CORNER_RADIUS_POLICY) + { + matchKey = Property::Key(Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY); } } - switch( matchKey.indexKey ) + switch(matchKey.indexKey) { - case DevelVisual::Property::SHADER: + case Toolkit::Visual::Property::SHADER: { Property::Map shaderMap; - if( value.Get( shaderMap ) ) + if(value.Get(shaderMap)) { - SetCustomShader( shaderMap ); + SetCustomShader(shaderMap); } break; } - case DevelVisual::Property::TRANSFORM: + case Toolkit::Visual::Property::TRANSFORM: { Property::Map map; - if( value.Get( map ) ) + if(value.Get(map)) { - mImpl->mTransform.SetPropertyMap( map ); + mImpl->mTransform.SetPropertyMap(map); } break; } - case DevelVisual::Property::PREMULTIPLIED_ALPHA: + case Toolkit::Visual::Property::PREMULTIPLIED_ALPHA: { bool premultipliedAlpha = false; - if( value.Get( premultipliedAlpha ) ) + if(value.Get(premultipliedAlpha)) { - EnablePreMultipliedAlpha( premultipliedAlpha ); + EnablePreMultipliedAlpha(premultipliedAlpha); } break; } - case DevelVisual::Property::MIX_COLOR: + case Toolkit::Visual::Property::MIX_COLOR: { Vector4 mixColor; - if( value.Get( mixColor ) ) + if(value.Get(mixColor)) + { + if(value.GetType() == Property::VECTOR4) + { + SetMixColor(mixColor); + } + else + { + Vector3 mixColor3(mixColor); + SetMixColor(mixColor3); + } + } + break; + } + case Toolkit::Visual::Property::OPACITY: + { + float opacity; + if(value.Get(opacity)) + { + mImpl->mMixColor.a = opacity; + SetMixColor(mImpl->mMixColor); + } + break; + } + case Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE: + { + Scripting::GetEnumerationProperty( + value, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT, mImpl->mFittingMode); + break; + } + case Toolkit::DevelVisual::Property::BORDERLINE_WIDTH: + { + float width; + if(value.Get(width)) + { + mImpl->mBorderlineWidth = width; + } + + if(mImpl->mBorderlineWidthIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mBorderlineWidthIndex, mImpl->mBorderlineWidth); + } + else if(DALI_UNLIKELY(mImpl->mRenderer && IsBorderlineRequired())) + { + // Unusual case. SetProperty called after OnInitialize(). + // Assume that DoAction call UPDATE_PROPERTY. + // We must regist properies into renderer, and update shader. + + // Borderline added by this action. Register property to renderer. + mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); + mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + + // Make Blend mode ON_WITHOUT_CULL for transparent mix color. + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL); + + // Change the shader must not be occured many times. we always have to use borderline feature. + mImpl->mAlwaysUsingBorderline = true; + + // Change shader + needUpdateShader = true; + } + break; + } + case Toolkit::DevelVisual::Property::BORDERLINE_COLOR: + { + Vector4 color; + if(value.Get(color)) + { + mImpl->mBorderlineColor = color; + } + + if(mImpl->mBorderlineColorIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mBorderlineColorIndex, mImpl->mBorderlineColor); + } + break; + } + case Toolkit::DevelVisual::Property::BORDERLINE_OFFSET: + { + float offset; + if(value.Get(offset)) + { + mImpl->mBorderlineOffset = offset; + } + + if(mImpl->mBorderlineOffsetIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mBorderlineOffsetIndex, mImpl->mBorderlineOffset); + } + break; + } + case Toolkit::DevelVisual::Property::CORNER_RADIUS: + { + if(value.GetType() == Property::VECTOR4) + { + // If CORNER_RADIUS Property is Vector4, + // Each values mean the radius of + // (top-left, top-right, bottom-right, bottom-left) + Vector4 radius; + if(value.Get(radius)) + { + mImpl->mCornerRadius = radius; + } + } + else + { + // If CORNER_RADIUS Property is float, + // Every corner radius have same value + float radius; + if(value.Get(radius)) + { + mImpl->mCornerRadius = Vector4(radius, radius, radius, radius); + } + } + + if(mImpl->mCornerRadiusIndex != Property::INVALID_INDEX) + { + mImpl->mRenderer.SetProperty(mImpl->mCornerRadiusIndex, mImpl->mCornerRadius); + } + else if(DALI_UNLIKELY(mImpl->mRenderer && IsRoundedCornerRequired())) { - SetMixColor( mixColor ); + // Unusual case. SetProperty called after OnInitialize(). + // Assume that DoAction call UPDATE_PROPERTY. + // We must regist properies into renderer, and update shader. + + // CornerRadius added by this action. Regist property to renderer. + mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); + mImpl->mRenderer.RegisterUniqueProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); + + // Change the shader must not be occured many times. we always have to use corner radius feature. + mImpl->mAlwaysUsingCornerRadius = true; + + if(!IsBorderlineRequired()) + { + // If IsBorderlineRequired is true, BLEND_MODE is already BlendMode::ON_WITHOUT_CULL. So we don't overwrite it. + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); + } + + // Change shader + needUpdateShader = true; + } + break; + } + case Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY: + { + int policy; + if(value.Get(policy)) + { + switch(policy) + { + case Toolkit::Visual::Transform::Policy::RELATIVE: + case Toolkit::Visual::Transform::Policy::ABSOLUTE: + { + mImpl->mCornerRadiusPolicy = policy; + if(DALI_UNLIKELY(mImpl->mRenderer && mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)) + { + // Unusual case. SetProperty called after OnInitialize(). + // Assume that DoAction call UPDATE_PROPERTY. + // We must update properies result into renderer + // Note : mImpl->mCornerRadiusIndex is not INVALID_INDEX. + // So CornerRadiusPolicy property is already registed. + mImpl->mRenderer.SetProperty(mImpl->mRenderer.GetPropertyIndex(CORNER_RADIUS_POLICY), mImpl->mCornerRadiusPolicy); + } + break; + } + default: + { + DALI_LOG_ERROR("Unsupported policy: %d\n", policy); + break; + } + } } break; } } } - DoSetProperties( propertyMap ); + DoSetProperties(propertyMap); + + if(DALI_UNLIKELY(needUpdateShader)) + { + UpdateShader(); + } } -void Visual::Base::SetTransformAndSize( const Property::Map& transform, Size controlSize ) +void Visual::Base::SetTransformAndSize(const Property::Map& transform, Size controlSize) { mImpl->mControlSize = controlSize; - mImpl->mTransform.UpdatePropertyMap( transform ); + mImpl->mTransform.UpdatePropertyMap(transform); #if defined(DEBUG_ENABLED) std::ostringstream oss; oss << transform; - DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, "Visual::Base::SetTransformAndSize(%s) - [\e[1;32mtransform: %s controlSize: (%3.1f, %3.1f)]\e[0m\n", - GetName().c_str(), oss.str().c_str(), controlSize.x, controlSize.y ); + DALI_LOG_INFO(gVisualBaseLogFilter, Debug::General, "Visual::Base::SetTransformAndSize(%s) - [\e[1;32mtransform: %s controlSize: (%3.1f, %3.1f)]\e[0m\n", GetName().c_str(), oss.str().c_str(), controlSize.x, controlSize.y); #endif OnSetTransform(); } -void Visual::Base::SetName( const std::string& name ) +void Visual::Base::SetName(const std::string& name) { mImpl->mName = name; } -const std::string& Visual::Base::GetName() +const std::string& Visual::Base::GetName() const { return mImpl->mName; } -float Visual::Base::GetHeightForWidth( float width ) +float Visual::Base::GetHeightForWidth(float width) { - float aspectCorrectedHeight = 0.f; + float aspectCorrectedHeight = 0.f; Vector2 naturalSize; - GetNaturalSize( naturalSize ); - if( naturalSize.width ) + GetNaturalSize(naturalSize); + if(naturalSize.width) { aspectCorrectedHeight = naturalSize.height * width / naturalSize.width; } return aspectCorrectedHeight; } -float Visual::Base::GetWidthForHeight( float height ) +float Visual::Base::GetWidthForHeight(float height) { - float aspectCorrectedWidth = 0.f; + float aspectCorrectedWidth = 0.f; Vector2 naturalSize; - GetNaturalSize( naturalSize ); - if( naturalSize.height > 0.0f ) + GetNaturalSize(naturalSize); + if(naturalSize.height > 0.0f) { aspectCorrectedWidth = naturalSize.width * height / naturalSize.height; } return aspectCorrectedWidth; } -void Visual::Base::GetNaturalSize( Vector2& naturalSize ) +void Visual::Base::GetNaturalSize(Vector2& naturalSize) { naturalSize = Vector2::ZERO; } -void Visual::Base::SetDepthIndex( float index ) +void Visual::Base::DoAction(const Property::Index actionId, const Property::Value attributes) +{ + OnDoAction(actionId, attributes); + + // Check if action is valid for this visual type and perform action if possible + switch(actionId) + { + case DevelVisual::Action::UPDATE_PROPERTY: + { + const Property::Map* map = attributes.GetMap(); + if(map) + { + SetProperties(*map); + } + break; + } + } +} + +void Visual::Base::SetDepthIndex(int index) { mImpl->mDepthIndex = index; - if( mImpl->mRenderer ) + if(mImpl->mRenderer) { - mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_INDEX, mImpl->mDepthIndex ); + mImpl->mRenderer.SetProperty(Renderer::Property::DEPTH_INDEX, mImpl->mDepthIndex); } } -float Visual::Base::GetDepthIndex() const +int Visual::Base::GetDepthIndex() const { return mImpl->mDepthIndex; } -void Visual::Base::SetOnStage( Actor& actor ) +void Visual::Base::SetOnScene(Actor& actor) { - if( !IsOnStage() ) + if(!IsOnScene()) { // To display the actor correctly, renderer should not be added to actor until all required resources are ready. // Thus the calling of actor.AddRenderer() should happen inside derived class as base class does not know the exact timing. - DoSetOnStage( actor ); + DoSetOnScene(actor); - if( mImpl->mRenderer ) + if(mImpl->mRenderer) { - RegisterMixColor(); - - mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, IsPreMultipliedAlphaEnabled()); - mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_INDEX, mImpl->mDepthIndex ); - mImpl->mFlags |= Impl::IS_ON_STAGE; // Only sets the flag if renderer exists + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, IsPreMultipliedAlphaEnabled()); + mImpl->mRenderer.SetProperty(Renderer::Property::DEPTH_INDEX, mImpl->mDepthIndex); } + + mImpl->mFlags |= Impl::IS_ON_SCENE; } } -void Visual::Base::SetOffStage( Actor& actor ) +void Visual::Base::SetOffScene(Actor& actor) { - if( IsOnStage() ) + if(IsOnScene()) { - DoSetOffStage( actor ); - mImpl->mMixColorIndex = Property::INVALID_INDEX; - mImpl->mFlags &= ~Impl::IS_ON_STAGE; + DoSetOffScene(actor); + mImpl->mFlags &= ~Impl::IS_ON_SCENE; } } -void Visual::Base::CreatePropertyMap( Property::Map& map ) const +void Visual::Base::CreatePropertyMap(Property::Map& map) const { - DoCreatePropertyMap( map ); + if(mImpl->mRenderer) + { + // Update values from Renderer + mImpl->mMixColor = mImpl->mRenderer.GetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR); + mImpl->mMixColor.a = mImpl->mRenderer.GetProperty(DevelRenderer::Property::OPACITY); + + mImpl->mTransform.mOffset = mImpl->mRenderer.GetProperty(VisualRenderer::Property::TRANSFORM_OFFSET); + mImpl->mTransform.mSize = mImpl->mRenderer.GetProperty(VisualRenderer::Property::TRANSFORM_SIZE); - if( mImpl->mCustomShader ) + if(mImpl->mCornerRadiusIndex != Property::INVALID_INDEX) + { + mImpl->mCornerRadius = mImpl->mRenderer.GetProperty(mImpl->mCornerRadiusIndex); + } + if(mImpl->mBorderlineWidthIndex != Property::INVALID_INDEX) + { + mImpl->mBorderlineWidth = mImpl->mRenderer.GetProperty(mImpl->mBorderlineWidthIndex); + } + if(mImpl->mBorderlineColorIndex != Property::INVALID_INDEX) + { + mImpl->mBorderlineColor = mImpl->mRenderer.GetProperty(mImpl->mBorderlineColorIndex); + } + if(mImpl->mBorderlineOffsetIndex != Property::INVALID_INDEX) + { + mImpl->mBorderlineOffset = mImpl->mRenderer.GetProperty(mImpl->mBorderlineOffsetIndex); + } + } + + DoCreatePropertyMap(map); + + if(mImpl->mCustomShader) { - mImpl->mCustomShader->CreatePropertyMap( map ); + mImpl->mCustomShader->CreatePropertyMap(map); } Property::Map transform; - mImpl->mTransform.GetPropertyMap( transform ); - map.Insert( DevelVisual::Property::TRANSFORM, transform ); + mImpl->mTransform.GetPropertyMap(transform); + map.Insert(Toolkit::Visual::Property::TRANSFORM, transform); - bool premultipliedAlpha( IsPreMultipliedAlphaEnabled() ); - map.Insert( DevelVisual::Property::PREMULTIPLIED_ALPHA, premultipliedAlpha ); + bool premultipliedAlpha(IsPreMultipliedAlphaEnabled()); + map.Insert(Toolkit::Visual::Property::PREMULTIPLIED_ALPHA, premultipliedAlpha); // Note, Color and Primitive will also insert their own mix color into the map - // which is ok, because they have a different key value range. - map.Insert( DevelVisual::Property::MIX_COLOR, GetMixColor() ); + // which is ok, because they have a different key value range, but uses same cached value anyway. + map.Insert(Toolkit::Visual::Property::MIX_COLOR, mImpl->mMixColor); // vec4 + map.Insert(Toolkit::Visual::Property::OPACITY, mImpl->mMixColor.a); + + auto fittingModeString = Scripting::GetLinearEnumerationName( + mImpl->mFittingMode, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT); + map.Insert(Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE, fittingModeString); + + map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_COLOR, mImpl->mBorderlineColor); + map.Insert(Toolkit::DevelVisual::Property::BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + + map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS, mImpl->mCornerRadius); + map.Insert(Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, static_cast(mImpl->mCornerRadiusPolicy)); +} + +void Visual::Base::CreateInstancePropertyMap(Property::Map& map) const +{ + DoCreateInstancePropertyMap(map); + + if(mImpl->mCustomShader) + { + mImpl->mCustomShader->CreatePropertyMap(map); + } } -void Visual::Base::EnablePreMultipliedAlpha( bool preMultipled ) +void Visual::Base::EnablePreMultipliedAlpha(bool preMultiplied) { - if( preMultipled ) + if(preMultiplied) { mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA; } @@ -272,9 +642,10 @@ void Visual::Base::EnablePreMultipliedAlpha( bool preMultipled ) mImpl->mFlags &= ~Impl::IS_PREMULTIPLIED_ALPHA; } - if( mImpl->mRenderer ) + if(mImpl->mRenderer) { - mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, preMultipled); + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, preMultiplied); + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA, preMultiplied); } } @@ -283,65 +654,144 @@ bool Visual::Base::IsPreMultipliedAlphaEnabled() const return mImpl->mFlags & Impl::IS_PREMULTIPLIED_ALPHA; } -void Visual::Base::DoSetOffStage( Actor& actor ) +void Visual::Base::DoSetOffScene(Actor& actor) { - actor.RemoveRenderer( mImpl->mRenderer ); - mImpl->mRenderer.Reset(); + actor.RemoveRenderer(mImpl->mRenderer); } -bool Visual::Base::IsOnStage() const +bool Visual::Base::IsOnScene() const { - return mImpl->mFlags & Impl::IS_ON_STAGE; + return mImpl->mFlags & Impl::IS_ON_SCENE; } -bool Visual::Base::IsFromCache() const +bool Visual::Base::IsRoundedCornerRequired() const { - return mImpl->mFlags & Impl::IS_FROM_CACHE; + // If VisualType doesn't support rounded corner, always return false. + if(IsTypeAvailableForCornerRadius(mImpl->mType)) + { + if(mImpl->mRenderer && mImpl->mCornerRadiusIndex != Property::INVALID_INDEX) + { + // Update values from Renderer + mImpl->mCornerRadius = mImpl->mRenderer.GetProperty(mImpl->mCornerRadiusIndex); + } + return !(mImpl->mCornerRadius == Vector4::ZERO) || mImpl->mAlwaysUsingCornerRadius; + } + return false; } -void Visual::Base::RegisterMixColor() +bool Visual::Base::IsBorderlineRequired() const { - // Only register if not already registered. - // (Color and Primitive visuals will register their own and save to this index) - if( mImpl->mMixColorIndex == Property::INVALID_INDEX ) + // If VisualType doesn't support borderline, always return false. + if(IsTypeAvailableForBorderline(mImpl->mType)) { - mImpl->mMixColorIndex = DevelHandle::RegisterProperty( - mImpl->mRenderer, - Toolkit::DevelVisual::Property::MIX_COLOR, - MIX_COLOR, - mImpl->mMixColor ); - - if( mImpl->mMixColor.a < 1.f ) + if(mImpl->mRenderer && mImpl->mBorderlineWidthIndex != Property::INVALID_INDEX) { - mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON ); + // Update values from Renderer + mImpl->mBorderlineWidth = mImpl->mRenderer.GetProperty(mImpl->mBorderlineWidthIndex); } + return !EqualsZero(mImpl->mBorderlineWidth) || mImpl->mAlwaysUsingBorderline; + } + return false; +} + +void Visual::Base::OnDoAction(const Property::Index actionId, const Property::Value& attributes) +{ + // May be overriden by derived class +} + +void Visual::Base::RegisterMixColor() +{ + if(mImpl->mRenderer) + { + // All visual renderers now use same mix color / opacity properties. + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR, Vector3(mImpl->mMixColor)); + mImpl->mRenderer.SetProperty(DevelRenderer::Property::OPACITY, mImpl->mMixColor.a); float preMultipliedAlpha = 0.0f; - if( IsPreMultipliedAlphaEnabled() ) + if(IsPreMultipliedAlphaEnabled()) { preMultipliedAlpha = 1.0f; } - mImpl->mRenderer.RegisterProperty( "preMultipliedAlpha", preMultipliedAlpha ); + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA, preMultipliedAlpha); } } -void Visual::Base::SetMixColor( const Vector4& color ) +void Visual::Base::SetMixColor(const Vector4& color) { mImpl->mMixColor = color; - if( mImpl->mRenderer ) + if(mImpl->mRenderer) + { + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR, Vector3(color)); + mImpl->mRenderer.SetProperty(DevelRenderer::Property::OPACITY, color.a); + } +} + +void Visual::Base::SetMixColor(const Vector3& color) +{ + mImpl->mMixColor.r = color.r; + mImpl->mMixColor.g = color.g; + mImpl->mMixColor.b = color.b; + + if(mImpl->mRenderer) { - mImpl->mRenderer.SetProperty( mImpl->mMixColorIndex, color ); - if( color.a < 1.f ) + mImpl->mRenderer.SetProperty(VisualRenderer::Property::VISUAL_MIX_COLOR, color); + } +} + +void Visual::Base::AddEventObserver(Visual::EventObserver& observer) +{ + mImpl->mEventObserver = &observer; +} + +void Visual::Base::RemoveEventObserver(Visual::EventObserver& observer) +{ + mImpl->mEventObserver = NULL; +} + +void Visual::Base::ResourceReady(Toolkit::Visual::ResourceStatus resourceStatus) +{ + if(mImpl->mResourceStatus != resourceStatus) + { + mImpl->mResourceStatus = resourceStatus; + + if(mImpl->mEventObserver) { - mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON ); + // observer is currently a control impl + mImpl->mEventObserver->ResourceReady(*this); } } } -const Vector4& Visual::Base::GetMixColor() const +bool Visual::Base::IsResourceReady() const +{ + return (mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::READY || + mImpl->mResourceStatus == Toolkit::Visual::ResourceStatus::FAILED); +} + +bool Visual::Base::IsSynchronousLoadingRequired() const +{ + return (mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING); +} + +Toolkit::Visual::Type Visual::Base::GetType() const +{ + return mImpl->mType; +} + +Toolkit::Visual::ResourceStatus Visual::Base::GetResourceStatus() const { - return mImpl->mMixColor; + return mImpl->mResourceStatus; +} + +Visual::FittingMode Visual::Base::GetFittingMode() const +{ + return mImpl->mFittingMode; +} + +Visual::Base& Visual::Base::GetVisualObject() +{ + return *this; } Renderer Visual::Base::GetRenderer() @@ -349,25 +799,139 @@ Renderer Visual::Base::GetRenderer() return mImpl->mRenderer; } +Property::Index Visual::Base::GetIntKey(Property::Key key) +{ + if(key.type == Property::Key::INDEX) + { + return key.indexKey; + } + + if(key.stringKey == ANCHOR_POINT) + { + return Toolkit::Visual::Transform::Property::ANCHOR_POINT; + } + else if(key.stringKey == EXTRA_SIZE) + { + return Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE; + } + else if(key.stringKey == MIX_COLOR) + { + return Toolkit::Visual::Property::MIX_COLOR; + } + else if(key.stringKey == OPACITY) + { + return Toolkit::Visual::Property::OPACITY; + } + else if(key.stringKey == OFFSET) + { + return Toolkit::Visual::Transform::Property::OFFSET; + } + else if(key.stringKey == OFFSET_POLICY) + { + return Toolkit::Visual::Transform::Property::OFFSET_POLICY; + } + else if(key.stringKey == ORIGIN) + { + return Toolkit::Visual::Transform::Property::ORIGIN; + } + else if(key.stringKey == PREMULTIPLIED_ALPHA) + { + return Toolkit::Visual::Property::PREMULTIPLIED_ALPHA; + } + else if(key.stringKey == CUSTOM_SHADER) + { + return Toolkit::Visual::Property::SHADER; + } + else if(key.stringKey == SIZE) + { + return Toolkit::Visual::Transform::Property::SIZE; + } + else if(key.stringKey == SIZE_POLICY) + { + return Toolkit::Visual::Transform::Property::SIZE_POLICY; + } + else if(key.stringKey == TRANSFORM) + { + return Toolkit::Visual::Property::TRANSFORM; + } + else if(key.stringKey == VISUAL_FITTING_MODE) + { + return Toolkit::DevelVisual::Property::VISUAL_FITTING_MODE; + } + else if(key.stringKey == CORNER_RADIUS) + { + return Toolkit::DevelVisual::Property::CORNER_RADIUS; + } + else if(key.stringKey == CORNER_RADIUS_POLICY) + { + return Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY; + } + else if(key.stringKey == BORDERLINE_WIDTH) + { + return Toolkit::DevelVisual::Property::BORDERLINE_WIDTH; + } + else if(key.stringKey == BORDERLINE_COLOR) + { + return Toolkit::DevelVisual::Property::BORDERLINE_COLOR; + } + else if(key.stringKey == BORDERLINE_OFFSET) + { + return Toolkit::DevelVisual::Property::BORDERLINE_OFFSET; + } + + return Property::INVALID_INDEX; +} -Property::Index Visual::Base::GetPropertyIndex( Property::Key key ) +Property::Index Visual::Base::GetPropertyIndex(Property::Key key) { - Property::Index index = DevelHandle::GetPropertyIndex( mImpl->mRenderer, key ); + switch(GetIntKey(key)) + { + case Dali::Toolkit::Visual::Transform::Property::OFFSET: + { + return VisualRenderer::Property::TRANSFORM_OFFSET; + } + case Dali::Toolkit::Visual::Transform::Property::SIZE: + { + return VisualRenderer::Property::TRANSFORM_SIZE; + } + case Dali::Toolkit::Visual::Transform::Property::ORIGIN: + { + return VisualRenderer::Property::TRANSFORM_ORIGIN; + } + case Dali::Toolkit::Visual::Transform::Property::ANCHOR_POINT: + { + return VisualRenderer::Property::TRANSFORM_ANCHOR_POINT; + } + case Dali::Toolkit::Visual::Property::MIX_COLOR: + { + return VisualRenderer::Property::VISUAL_MIX_COLOR; + } + case Dali::Toolkit::Visual::Property::OPACITY: + { + return DevelRenderer::Property::OPACITY; + } + case Dali::Toolkit::Visual::Property::PREMULTIPLIED_ALPHA: + { + return VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA; + } + } + + Property::Index index = mImpl->mRenderer.GetPropertyIndex(key); - if( index == Property::INVALID_INDEX ) + if(index == Property::INVALID_INDEX) { // Is it a shader property? Shader shader = mImpl->mRenderer.GetShader(); - index = DevelHandle::GetPropertyIndex( shader, key ); - if( index != Property::INVALID_INDEX ) + index = shader.GetPropertyIndex(key); + if(index != Property::INVALID_INDEX) { // Yes - we should register it in the Renderer so it can be set / animated // independently, as shaders are shared across multiple renderers. - std::string keyName; - Property::Index keyIndex( Property::INVALID_KEY ); - if( key.type == Property::Key::INDEX ) + std::string keyName; + Property::Index keyIndex(Property::INVALID_KEY); + if(key.type == Property::Key::INDEX) { - keyName = shader.GetPropertyName( index ); + keyName = shader.GetPropertyName(index); keyIndex = key.indexKey; } else @@ -375,146 +939,280 @@ Property::Index Visual::Base::GetPropertyIndex( Property::Key key ) keyName = key.stringKey; // Leave keyIndex as INVALID_KEY - it can still be registered against the string key. } - Property::Value value = shader.GetProperty( index ); - index = DevelHandle::RegisterProperty( mImpl->mRenderer, keyIndex, keyName, value ); + Property::Value value = shader.GetProperty(index); + + // We already know that mRenderer didn't have property. So we can assume that it is unique. + index = mImpl->mRenderer.RegisterUniqueProperty(keyIndex, keyName, value); } } return index; } void Visual::Base::SetupTransition( - Dali::Animation& transition, + Dali::Animation& transition, Internal::TransitionData::Animator& animator, - Property::Index index ) + Property::Index index, + Property::Value& initialValue, + Property::Value& targetValue) { - if( index != Property::INVALID_INDEX ) + if(index != Property::INVALID_INDEX) { - if( mImpl->mRenderer ) + if(mImpl->mRenderer) { - if( animator.animate == false ) + if(animator.animate == false) { - mImpl->mRenderer.SetProperty( index, animator.targetValue ); + mImpl->mRenderer.SetProperty(index, targetValue); } else { - if( animator.initialValue.GetType() != Property::NONE ) + if(animator.initialValue.GetType() != Property::NONE) { - mImpl->mRenderer.SetProperty( index, animator.initialValue ); + mImpl->mRenderer.SetProperty(index, initialValue); } - if( ! transition ) + if(!transition) { - transition = Dali::Animation::New( 0.1f ); + transition = Dali::Animation::New(0.1f); } - transition.AnimateTo( Property( mImpl->mRenderer, index ), - animator.targetValue, - animator.alphaFunction, - TimePeriod( animator.timePeriodDelay, - animator.timePeriodDuration ) ); + transition.AnimateTo(Property(mImpl->mRenderer, index), + targetValue, + animator.alphaFunction, + TimePeriod(animator.timePeriodDelay, + animator.timePeriodDuration)); } } } } void Visual::Base::AnimateProperty( - Dali::Animation& transition, - Internal::TransitionData::Animator& animator ) + Dali::Animation& transition, + Internal::TransitionData::Animator& animator) { #if defined(DEBUG_ENABLED) { std::ostringstream oss; oss << "Visual::Base::AnimateProperty(Visual:" << mImpl->mName << " Property:" << animator.propertyKey << " Target: " << animator.targetValue << std::endl; - DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, oss.str().c_str() ); + DALI_LOG_INFO(gVisualBaseLogFilter, Debug::General, oss.str().c_str()); } #endif - Property::Index index = Property::INVALID_INDEX; + if(animator.propertyKey == Toolkit::Visual::Property::MIX_COLOR || + animator.propertyKey == MIX_COLOR || + (mImpl->mType == Toolkit::Visual::COLOR && + animator.propertyKey == ColorVisual::Property::MIX_COLOR) || + (mImpl->mType == Toolkit::Visual::PRIMITIVE && + animator.propertyKey == PrimitiveVisual::Property::MIX_COLOR)) + { + AnimateMixColorProperty(transition, animator); + } + else if(animator.propertyKey == Toolkit::Visual::Property::OPACITY || + animator.propertyKey == OPACITY) + { + AnimateOpacityProperty(transition, animator); + } + else if(mImpl->mRenderer) + { + AnimateRendererProperty(transition, animator); + } +} + +void Visual::Base::AnimateOpacityProperty( + Dali::Animation& transition, + Internal::TransitionData::Animator& animator) +{ + float targetOpacity; + if(animator.targetValue.Get(targetOpacity)) + { + mImpl->mMixColor.a = targetOpacity; + } - bool isMixColor = false; - bool isMixColorOpaque = true; + SetupTransition(transition, animator, DevelRenderer::Property::OPACITY, animator.initialValue, animator.targetValue); +} + +void Visual::Base::AnimateRendererProperty( + Dali::Animation& transition, + Internal::TransitionData::Animator& animator) +{ + // Get actual renderer index (will convert transform keys into visualproperty indices) + Property::Index index = GetPropertyIndex(animator.propertyKey); - // Get the property index - if( animator.propertyKey == Toolkit::DevelVisual::Property::MIX_COLOR || - animator.propertyKey == MIX_COLOR ) + if(index != Property::INVALID_INDEX) { - isMixColor = true; - index = mImpl->mMixColorIndex; + if(animator.targetValue.GetType() != Property::NONE) + { + // Try writing target value into transform property map + // if it's not a valid key, then it won't alter mTransform + Property::Map map; + if(animator.propertyKey.type == Property::Key::INDEX) + { + map.Add(animator.propertyKey.indexKey, animator.targetValue); + } + else + { + map.Add(animator.propertyKey.stringKey, animator.targetValue); + } + + mImpl->mTransform.UpdatePropertyMap(map); + } + SetupTransition(transition, animator, index, animator.initialValue, animator.targetValue); + } +} - Vector4 initialColor; - if( animator.initialValue.Get(initialColor) ) // if there is an initial color, test it +void Visual::Base::AnimateMixColorProperty( + Dali::Animation& transition, + Internal::TransitionData::Animator& animator) +{ + bool animateOpacity = false; + + Property::Value initialOpacity; + Property::Value targetOpacity; + Property::Value initialMixColor; + Property::Value targetMixColor; + + Vector4 initialColor; + if(animator.initialValue.Get(initialColor)) + { + if(animator.initialValue.GetType() == Property::VECTOR4) { - isMixColorOpaque = initialColor.a >= 1.0f; + // if there is an initial color specifying alpha, test it + initialOpacity = initialColor.a; } - else + initialMixColor = Vector3(initialColor); + } + + // Set target value into data store + if(animator.targetValue.GetType() != Property::NONE) + { + Vector4 mixColor; + animator.targetValue.Get(mixColor); + if(animator.targetValue.GetType() == Property::VECTOR4) { - isMixColorOpaque = mImpl->mMixColor.a >= 1.0f; // otherwise, test the current color + mImpl->mMixColor.a = mixColor.a; + targetOpacity = mixColor.a; + animateOpacity = true; } + + mImpl->mMixColor.r = mixColor.r; + mImpl->mMixColor.g = mixColor.g; + mImpl->mMixColor.b = mixColor.b; + targetMixColor = Vector3(mixColor); } - else if( mImpl->mRenderer ) + + SetupTransition(transition, animator, VisualRenderer::Property::VISUAL_MIX_COLOR, initialMixColor, targetMixColor); + + if(animateOpacity) { - index = GetPropertyIndex( animator.propertyKey ); + SetupTransition(transition, animator, DevelRenderer::Property::OPACITY, initialOpacity, targetOpacity); } +} - // Set target value into data store - if( animator.targetValue.GetType() != Property::NONE ) +Dali::Property Visual::Base::GetPropertyObject(Dali::Property::Key key) +{ + if(!mImpl->mRenderer) { - if( isMixColor ) + Handle handle; + return Dali::Property(handle, Property::INVALID_INDEX); + } + + // Default animatable properties from VisualRenderer + switch(GetIntKey(key)) + { + case Toolkit::Visual::Property::MIX_COLOR: { - animator.targetValue.Get( mImpl->mMixColor ); + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::VISUAL_MIX_COLOR); } - else + case Toolkit::Visual::Property::OPACITY: { - // Note: there may be several of these calls if more than one - // transform property is animated. - Property::Map map; - if( animator.propertyKey.type == Property::Key::INDEX ) - { - map.Add( animator.propertyKey.indexKey, animator.targetValue ); - } - else + return Dali::Property(mImpl->mRenderer, DevelRenderer::Property::OPACITY); + } + case Toolkit::Visual::Transform::Property::OFFSET: + { + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::TRANSFORM_OFFSET); + } + case Toolkit::Visual::Transform::Property::SIZE: + { + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::TRANSFORM_SIZE); + } + default: + { + if(key.type == Property::Key::INDEX && + ((mImpl->mType == Toolkit::Visual::COLOR && key.indexKey == ColorVisual::Property::MIX_COLOR) || + (mImpl->mType == Toolkit::Visual::PRIMITIVE && key.indexKey == PrimitiveVisual::Property::MIX_COLOR))) { - map.Add( animator.propertyKey.stringKey, animator.targetValue ); + return Dali::Property(mImpl->mRenderer, VisualRenderer::Property::VISUAL_MIX_COLOR); } - - mImpl->mTransform.UpdatePropertyMap( map ); } } - if( index != Property::INVALID_INDEX ) + // Other cases + Property::Index index = GetPropertyIndex(key); + if(index == Property::INVALID_INDEX) { - SetupTransition( transition, animator, index ); + if(IsTypeAvailableForBorderline(mImpl->mType) && + ((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_WIDTH) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_WIDTH) || + (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_COLOR) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_COLOR) || + (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_OFFSET) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_OFFSET))) + { + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL); - // For mix color, ensure the blend mode is on if the initial or final values are not opaque, - // and that it is turned off after the animation ends if the final value is opaque - if( isMixColor && (!isMixColorOpaque || mImpl->mMixColor.a < 1.0f) ) + // Register borderline properties + mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth); + mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor); + mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset); + + // Borderline is animated now. we always have to use borderline feature. + mImpl->mAlwaysUsingBorderline = true; + + index = mImpl->mRenderer.GetPropertyIndex(key); + + // Change shader + UpdateShader(); + } + else if(IsTypeAvailableForCornerRadius(mImpl->mType) && ((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::CORNER_RADIUS) || (key.type == Property::Key::STRING && key.stringKey == CORNER_RADIUS))) { - mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON ); + // Register CORNER_RADIUS property + mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterUniqueProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius); + mImpl->mRenderer.RegisterUniqueProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy); + + // CornerRadius is animated now. we always have to use corner radius feature. + mImpl->mAlwaysUsingCornerRadius = true; - if( animator.animate == true && mImpl->mMixColor.a >= 1.0f ) + if(!IsBorderlineRequired()) { - // When it becomes opaque, set the blend mode back to automatically - if( ! mImpl->mBlendSlotDelegate ) - { - mImpl->mBlendSlotDelegate = new SlotDelegate(this); - } - transition.FinishedSignal().Connect( *(mImpl->mBlendSlotDelegate), - &Visual::Base::OnMixColorFinished ); + // If IsBorderlineRequired is true, BLEND_MODE is already BlendMode::ON_WITHOUT_CULL. So we don't overwrite it. + mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON); } + + index = mImpl->mCornerRadiusIndex; + + // Change shader + UpdateShader(); + } + else + { + // We can't find the property in the base class. + // Request to child class + return OnGetPropertyObject(key); } } -} - -void Visual::Base::OnMixColorFinished( Animation& animation ) -{ - if( mImpl->mRenderer ) + else { - DALI_LOG_INFO( gVisualBaseLogFilter, Debug::General, "Visual::Base::OnMixColorFinished()\n"); - mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, - ( mImpl->mMixColor.a < 1.0 ) ? BlendMode::ON : BlendMode::AUTO ); + if(index == mImpl->mBorderlineWidthIndex || + index == mImpl->mBorderlineColorIndex || + index == mImpl->mBorderlineOffsetIndex) + { + // Borderline is animated now. we always have to use borderline feature. + mImpl->mAlwaysUsingBorderline = true; + } + if(index == mImpl->mCornerRadiusIndex) + { + // CornerRadius is animated now. we always have to use corner radius feature. + mImpl->mAlwaysUsingCornerRadius = true; + } } - delete mImpl->mBlendSlotDelegate; - mImpl->mBlendSlotDelegate = NULL; + + return Dali::Property(mImpl->mRenderer, index); } } // namespace Internal