*
*/
-#include <dali/dali.h>
-#include <dali-toolkit/public-api/shader-effects/bouncing-effect.h>
+// EXTERNAL INCLUDES
+#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/animation/animation.h>
+#include <dali/public-api/common/intrusive-ptr.h>
+#include <dali/public-api/math/vector4.h>
+#include <dali/public-api/object/property-notification.h>
+#include <dali/public-api/object/ref-object.h>
namespace Dali
{
/**
* ScrollOvershootIndicator constructor.
- * @param[in] scrollView reference to ScrollView implementation
- * or horizontally (false)
*/
- ScrollOvershootIndicator( Scrollable& scrollable);
+ ScrollOvershootIndicator();
/**
* Virtual destructor
virtual ~ScrollOvershootIndicator();
/**
- * Enables and disables the indicator
- * ¶m[in] enable true to enable, false to disable
+ * Attaches the scroll indicator to a scrollable actor
+ *
+ * ¶m[in] scrollable The scrollable actor to attach to
+ */
+ void AttachToScrollable(Scrollable& scrollable);
+
+ /**
+ * Detaches the scroll indicator from a scrollable actor
+ *
+ * ¶m[in] scrollable The scrollable actor to detach from
*/
- void Enable(bool enable);
+ void DetachFromScrollable(Scrollable& scrollable);
/**
* Resets the indicator
void Reset();
/**
+ * Clears the overshoot
+ */
+ void ClearOvershoot();
+
+ /**
* Create an initialized ScrollOvershootIndicator
- * @param[in] scrollView reference to ScrollView implementation
- * or horizontally (false)
+ *
* @return A pointer to the created ScrollOvershootIndicator.
*/
- static ScrollOvershootIndicator* New( Scrollable& scrollable);
+ static ScrollOvershootIndicator* New();
+
+ /**
+ * Set the color of the overshoot effect.
+ * @parm[in] color The color of the overshoot effect
+ */
+ void SetOvershootEffectColor( const Vector4& color );
private:
- Scrollable& mScrollable; ///< Internal::Scrollable object
ScrollOvershootEffectPtr mEffectX; ///< effect used for x-axis/horizontal display
ScrollOvershootEffectPtr mEffectY; ///< effect used for y-axis/vertical display
};
*
* @param[in] vertical whether this effect is a vertical or horizontal one
*/
- ScrollOvershootEffect(bool vertical);
+ ScrollOvershootEffect( bool vertical );
/**
* Virtual destructor
*
* @return true or false
*/
- inline bool IsVertical() { return mVertical; }
+ bool IsVertical() const;
/**
* Applies the indicator effect, all derived effects must implement this function
*
* @param[in] scrollable the scrollable object to apply this effect to
*/
- virtual void Apply(Scrollable& scrollable) = 0;
+ virtual void Apply() = 0;
/**
* Removes the indicator effect, all derived effects must implement this function
*
* @param[in] scrollable the scrollable object to remove this effect from
*/
- virtual void Remove(Scrollable& scrollable) = 0;
+ virtual void Remove( Scrollable& scrollable ) = 0;
/**
* Resets this overshoot effect
virtual void Reset() = 0;
/**
- * Updates the constraints used for the overshoot effect
- *
- * @param[in] scrollable the container for the overshoot effect
+ * Sets up property notifications for overshoot values
*/
- virtual void UpdateConstraints(Actor& scrollable) {}
+ virtual void UpdatePropertyNotifications() {}
/**
- * Sets up property notifications for overshoot values
+ * @copydoc ScrollOvershootIndicator::SetOvershootEffectColor()
+ */
+ virtual void SetOvershootEffectColor( const Vector4& color ) = 0;
+
+ /**
+ * Sets shader overshoot value, either immediately of by animating over time
*
- * @param[in] scrollable the container for the overshoot effect
+ * @param[in] amount The amount to set overshoot to [-1.0f,1.0f]
+ * @param[in] animate Whether to animate or set immediately
*/
- virtual void SetPropertyNotifications(Actor& scrollable) {}
+ virtual void SetOvershoot(float amount, bool animate = true) = 0;
private:
bool mVertical; ///< whether this is a vertical/horizontal effect
*/
struct ScrollOvershootEffectRipple : public ScrollOvershootEffect, public ConnectionTracker
{
+ enum AnimationState
+ {
+ AnimatingIn = 0x01, ///< animating overshoot to 0
+ AnimatingOut = 0x02, ///< animating overshoot to negative (overshoot image displays in +ve area of screen)
+ AnimateBack = 0x04, ///< indicates that we need to animate overshoot back to zero immediately after it has finished animating in
+ };
+
public:
+
/**
* Create a new gradient overshoot effect, passing in whether it is vertical or horizontal
+ *
+ * @param[in] vertical Whether this indicator is vertical or horizontal
*/
- ScrollOvershootEffectRipple(bool vertical);
+ ScrollOvershootEffectRipple( bool vertical, Scrollable& scrollable );
/**
* @copydoc ScrollOvershootEffect::Apply
*/
- virtual void Apply(Scrollable& scrollable);
+ virtual void Apply();
/**
* @copydoc ScrollOvershootEffect::Remove
*/
- virtual void Remove(Scrollable& scrollable);
+ virtual void Remove( Scrollable& scrollable );
/**
* @copydoc ScrollOvershootEffect::Reset
virtual void Reset();
/**
- * @copydoc ScrollOvershootEffect::UpdateConstraints(Actor& scrollable)
- */
- virtual void UpdateConstraints(Actor& scrollable);
-
- /**
- * @copydoc ScrollOvershootEffect::SetPropertyNotification
+ * @copydoc ScrollOvershootEffect::UpdatePropertyNotifications
*/
- virtual void SetPropertyNotifications(Actor& scrollable);
+ void UpdatePropertyNotifications();
/**
- * Constrains the size of the gradient image
- * @param[in] current current position of the image actor
- * @param[in] parentSizeProperty size of the scrollable area so we can position image on the edge of it
- * @param[in] overshootProperty current overshoot amount for this indicator's axis
- * @return new position of the gradient image actor
+ * @copydoc ScrollOvershootEffect::SetOvershootEffectColor()
*/
- Vector3 PositionConstraint(const Vector3& current, const PropertyInput& parentSizeProperty, const PropertyInput& overshootProperty);
+ void SetOvershootEffectColor( const Vector4& color );
/**
- * Informs overshoot effect to update image position and to animate effect overshoot value for a
- * positive overshoot value from scrollview
+ * Updates the vibility of the overshoot image as well as updating its size, position and rotation
+ * This function is called when animation starts and finishes
*
- * @param[in] source the property notification that triggered this callback
+ * @param[in] visible Whether to set the image visible or not
*/
- void OnPositiveOvershootNotification(PropertyNotification& source);
+ void UpdateVisibility( bool visible );
/**
* Informs overshoot effect to update image position and to animate effect overshoot value for a
- * negative overshoot value from scrollview
+ * positive overshoot value from scrollview
*
* @param[in] source the property notification that triggered this callback
*/
- void OnNegativeOvershootNotification(PropertyNotification& source);
+ void OnOvershootNotification(PropertyNotification& source);
/**
- * Function to animate effect overshoot value either to -1.0f/1.0f or 0.0f
- *
- * @param[in] overshootAmount the amount to animate overshoot to [-1.0f,0.0f,1.0f]
+ * @copydoc ScrollOvershootEffect::SetOvershoot()
*/
- void AnimateScrollOvershoot(float overshootAmount);
+ void SetOvershoot(float amount, bool animate = true);
/**
* Connects to the animation finished signal of our overshoot animation
/**
* Creates a new ScrollOvershootEffectGradient objects and returns a pointer to it
+ *
* @param[in] vertical whether to create a vertical(true) or horizontal effect
* @return a pointer to the new effect
*/
- static ScrollOvershootEffectRipplePtr New( bool vertical );
+ static ScrollOvershootEffectRipplePtr New( bool vertical, Scrollable& scrollable );
private:
-
- float mMaxOvershootImageSize; ///< maximum size of the image when overshoot value is 1.0f
- ImageActor mOvershootImage; ///< the overshoot image...
- Animation mScrollOvershootAnimation; ///< animation
- bool mAnimatingOvershootOn; ///< whether we are currently animating overshoot to 1.0f/-1.0f (on) or to 0.0f (off)
- bool mAnimateOvershootOff; ///< whether we are currently animating overshoot to 1.0f/-1.0f (on) or to 0.0f (off)
- int mCanScrollPropertyIndex; ///< property index to a property that informs indicator if it is needed
- BouncingEffect mRippleEffect; // the ripple vertex/fragment shader effect
- PropertyNotification mOvershootPositiveNotification; // stores the property notification used for positive overshoot values
- PropertyNotification mOvershootNegativeNotification; // stores the property notification used for negative overshoot values
- ActiveConstraint mSizeConstraint; // active constraint handle used to store the image width constraint
- ActiveConstraint mPositionConstraint; // active constraint handle used to store the image position constraint
+ Actor mOvershootOverlay; ///< the actor which displays the overshoot effect
+ Scrollable& mAttachedScrollView; ///< the actor that this indicator has been attached to
+ Animation mScrollOvershootAnimation; ///< overshoot animation
+ PropertyNotification mOvershootIncreaseNotification;///< notification used to inform as overshoot increases
+ PropertyNotification mOvershootDecreaseNotification;///< notification used to inform as overshoot decreases
+ Property::Index mOvershootProperty; ///< index of the overshoot property in the scrollable actor
+ Property::Index mEffectOvershootProperty; ///< index of the effect's overshoot property
+ float mOvershoot; ///< last overshoot value as detected by notifications
+ unsigned short mAnimationStateFlags; ///< contains flags indicating the current state of the overshoot animation
};
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff