*/
// EXTERNAL INCLUDES
+#include <dali/public-api/animation/animation.h>
+#include <dali/public-api/common/intrusive-ptr.h>
#include <dali/public-api/images/image-operations.h>
#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/rendering/renderer.h>
#include <dali/public-api/rendering/shader.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
-#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+#include <dali-toolkit/internal/visuals/transition-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
namespace Dali
{
public:
/**
- * Initialisation of the visual, this API should only called by the VisualFactory:
- * request the geometry and shader from the cache, if not available, create and save to the cache for sharing;
- * record the property values.
- *
- * @param[in] actor The Actor the visual is applied to if, empty if the visual has not been applied to any Actor
+ * Setting the properties of the visual, this API should only called by the VisualFactory
* @param[in] propertyMap The properties for the requested Visual object.
*/
- void Initialize( Actor& actor, const Property::Map& propertyMap );
+ void SetProperties( const Property::Map& propertyMap );
+
+ /**
+ * @copydoc Toolkit::Visual::Base::SetName
+ */
+ void SetName( const std::string& name );
+
+ /**
+ * @copydoc Toolkit::Visual::Base::GetName
+ */
+ const std::string& GetName();
/**
* @copydoc Toolkit::Visual::Base::SetSize
*/
- virtual void SetSize( const Vector2& size );
+ void SetTransformAndSize( const Property::Map& transform, Size controlSize );
+
+ /**
+ * @copydoc Toolkit::Visual::Base::GetHeightForWidth
+ */
+ virtual float GetHeightForWidth( float width );
/**
- * @copydoc Toolkit::Visual::Base::GetSize
+ * @copydoc Toolkit::Visual::Base::GetWidthForHeight
*/
- const Vector2& GetSize() const;
+ virtual float GetWidthForHeight( float height );
/**
* @copydoc Toolkit::Visual::Base::GetNaturalSize
*/
- virtual void GetNaturalSize( Vector2& naturalSize ) const;
+ virtual void GetNaturalSize( Vector2& naturalSize );
/**
* @copydoc Toolkit::Visual::Base::SetDepthIndex
*
* @param[in] preMultipled whether alpha is pre-multiplied.
*/
- void EnablePreMultipliedAlpha( bool preMultipled );
+ void EnablePreMultipliedAlpha( bool preMultipled );
/**
* @brief Query whether alpha is pre-multiplied.
*/
Dali::Property::Value GetProperty( Dali::Property::Index index );
+ /**
+ * Gets currently staged renderer, or an empty handle if not staged
+ */
+ Renderer GetRenderer();
+
+ /**
+ * Sets the mix color ( including opacity ) of the visual.
+ * @param[in] mixColor The new mix color
+ */
+ void SetMixColor( const Vector4& color );
+
+ /**
+ * Sets the mix color of the visual.
+ * @param[in] mixColor The new mix color
+ */
+ void SetMixColor( const Vector3& color );
+
+ /**
+ * Gets the mix color of the visual.
+ * @return The mix color
+ */
+ const Vector4& GetMixColor() const;
+
+ /**
+ * Animate the property if it exists in the visual or renderer.
+ *
+ * If it's a visual property such as mix color or a transform property,
+ * saves the target value to the local data.
+ *
+ * If the visual isn't staged (i.e. it doesn't have a renderer),
+ * then this will not add an animation.
+ *
+ * @param[in] transition The animation to create or attach to
+ * @param[in] animator The animation parameters of the property.
+ */
+ void AnimateProperty( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator );
+
protected:
/**
virtual ~Base();
protected:
+
/**
* @brief Called by CreatePropertyMap() allowing sub classes to respond to the CreatePropertyMap event
*
virtual void DoCreatePropertyMap( Property::Map& map ) const = 0;
/**
- * @brief Called by Initialize() allowing sub classes to respond to the Initialize event
+ * @brief Called by SetProperties() allowing sub classes to set their properties
*
- * @param[in] actor The Actor the visual is applied to if, empty if the visual has not been applied to any Actor
* @param[in] propertyMap The properties for the requested Visual object.
*/
- virtual void DoInitialize( Actor& actor, const Property::Map& propertyMap ) {}
+ virtual void DoSetProperties( const Property::Map& propertyMap ) = 0;
-protected:
+ /**
+ * @brief Called when transform or control size changes
+ * ( Of use to SVG and Text visuals )
+ */
+ virtual void OnSetTransform() = 0;
/**
* @brief Called by SetOnStage() allowing sub classes to respond to the SetOnStage event
virtual void DoSetOffStage( Actor& actor );
protected:
+
/**
* @brief Gets the on stage state for this Visual
*
* @return Returns true if this Visual is on stage, false if it is off the stage
*/
- bool GetIsOnStage() const;
+ bool IsOnStage() const;
/**
* @brief Gets whether the Dali::Renderer is from a shared cache (and therefore any modifications will affect other users of that renderer)
*
* @return Returns true if the renderer is from shared cache, false otherwise
*/
- bool GetIsFromCache() const;
+ bool IsFromCache() const;
+
+private:
+
+ /**
+ * Register the mix color uniform on the Renderer and store the property index.
+ * Note, this is not used by Color or Primitive Visuals, which will use their
+ * own property index.
+ */
+ void RegisterMixColor();
+
+ /**
+ * Find the matching property on the renderer or shader. If it's a shader
+ * property, register it on the renderer in order to animate it for this
+ * visual independently.
+ * @param[in] key The key to match.
+ * @return the matching index, or INVALID_INDEX if it's not found
+ */
+ Property::Index GetPropertyIndex( Property::Key key );
+
+ /**
+ * Set up the transition. If no animation is required, then
+ * transition will be untouched.
+ *
+ * @param[in] transition The transition to use or set up.
+ * @param[in] animator The animation data to use
+ * @param[in] index The property index on the renderer to animate
+ * @param[in] initialValue The optional initial value
+ * @param[in] targetValue The target value to use
+ */
+ void SetupTransition( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator,
+ Property::Index index,
+ Property::Value& initialValue,
+ Property::Value& targetValue );
+
+ /**
+ * Animate the opacity property - Special handling to
+ * ensure that the blend mode is set to ON whilst animating,
+ * and set back to AUTO if it's opaque at the end of the
+ * animation.
+ *
+ * @param[in] transition The transition to use or set up.
+ * @param[in] animator The animation data to use
+ */
+ void AnimateOpacityProperty( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator );
-protected:
/**
- * @brief Called by SetProperty(). To be overriden by derived clases in order to set properties.
+ * Animate the renderer property - no special handling
*
- * @param [in] index The index of the property.
- * @param [in] propertyValue The new value of the property.
+ * @param[in] transition The transition to use or set up.
+ * @param[in] animator The animation data to use
*/
- virtual void DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue ) = 0;
+ void AnimateRendererProperty( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator );
/**
- * @brief Called by GetProperty(). To be overriden by derived classes in order to retrieve properties.
+ * Animate the mix color property.
*
- * @param [in] index The index of the property.
+ * If the animator is a vec3, then it only animates the color
+ * channels without animating the opacity. If it's a vec4, then it
+ * runs 2 animators, one for the the vec3 mixColor, and one for the
+ * opacity. (They are separate uniforms in the shader )
*
- * @return The property value.
+ * @param[in] transition The transition to use or set up.
+ * @param[in] animator The animation data to use
*/
- virtual Dali::Property::Value DoGetProperty( Dali::Property::Index index ) = 0;
+ void AnimateMixColorProperty( Dali::Animation& transition,
+ Internal::TransitionData::Animator& animator );
-private:
+ /**
+ * Set up the right blend mode if the opacity is being animated.
+ * Also ensure that when the animation finishes, the blend mode is
+ * set to the appropriate value. It also uses the target value as
+ * set into mMixColor.
+ *
+ * @param[in] transition The transition to listen to
+ * @param[in] isInitialOpaque Whether the initial value is opaque
+ * @param[in] animating If the transition animates the value.
+ */
+ void SetupBlendMode( Dali::Animation& transition,
+ bool isInitialOpaque, bool animating );
+
+ /**
+ * When a mix color animation has finished, ensure the blend mode is set back
+ * to the right value for the target opacity.
+ */
+ void OnMixColorFinished( Animation& animation );
// Undefined
Base( const Visual::Base& visual );
VisualFactoryCache& mFactoryCache;
};
+typedef IntrusivePtr<Base> BasePtr;
+
} // namspace Visual
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff