(AnimatedVectorImageVisual) Add some features

- Add Property::CURRNT_PROGRESS
- Add Action::UPDATE_PROPERTY

Change-Id: I61b3bc076ac6cacd1a0fe98af78c112a53f88a9e

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-AnimatedVectorImageVisual.cpp b/automated-tests/src/dali-toolkit/utc-Dali-AnimatedVectorImageVisual.cpp
index d57d6b7..bda987d 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-AnimatedVectorImageVisual.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-AnimatedVectorImageVisual.cpp
@@ -543,6 +543,10 @@ int UtcDaliAnimatedVectorImageVisualPlayRange(void)
   Renderer renderer = actor.GetRendererAt( 0u );
   DALI_TEST_CHECK( renderer );
 
+  Property::Map map = actor.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+  Property::Value* value = map.Find( DevelImageVisual::Property::PLAY_RANGE );
+  DALI_TEST_EQUALS( value->Get< Vector2 >(), playRange, TEST_LOCATION );
+
   END_TEST;
 }
 
@@ -587,3 +591,114 @@ int UtcDaliAnimatedVectorImageVisualAnimationFinishedSignal(void)
 
   END_TEST;
 }
+
+int UtcDaliAnimatedVectorImageVisualJumpToCurrentProgress(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcDaliAnimatedVectorImageVisualJumpToCurrentProgress" );
+
+  Property::Map propertyMap;
+  propertyMap.Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
+             .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME  );
+
+  Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
+  DALI_TEST_CHECK( visual );
+
+  DummyControl actor = DummyControl::New( true );
+  DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+  dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+  Vector2 controlSize( 20.f, 30.f );
+  actor.SetSize( controlSize );
+
+  Stage::GetCurrent().Add( actor );
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+  DevelControl::DoAction( actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO, 0.6f );
+
+  application.SendNotification();
+  application.Render();
+
+  Property::Map map = actor.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+  Property::Value* value = map.Find( DevelImageVisual::Property::CURRENT_PROGRESS );
+  DALI_TEST_EQUALS( value->Get< float >(), 0.6f, TEST_LOCATION );
+
+  Vector2 playRange( 0.0f, 0.4f );
+
+  Property::Map attributes;
+  attributes.Add( DevelImageVisual::Property::PLAY_RANGE, playRange );
+  DevelControl::DoAction( actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY, attributes );
+
+  DevelControl::DoAction( actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::JUMP_TO, 0.8f );
+
+  application.SendNotification();
+  application.Render();
+
+  map = actor.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+  value = map.Find( DevelImageVisual::Property::CURRENT_PROGRESS );
+  DALI_TEST_EQUALS( value->Get< float >(), 0.4f, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAnimatedVectorImageVisualUpdateProperty(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( "UtcDaliAnimatedVectorImageVisualJumpToCurrentProgress" );
+
+  Vector2 playRange( 0.2f, 0.8f );
+
+  Property::Map propertyMap;
+  propertyMap.Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
+             .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME  )
+             .Add( DevelImageVisual::Property::LOOP_COUNT, 3  )
+             .Add( DevelImageVisual::Property::PLAY_RANGE, playRange  );
+
+  Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
+  DALI_TEST_CHECK( visual );
+
+  DummyControl actor = DummyControl::New( true );
+  DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+  dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+
+  Vector2 controlSize( 20.f, 30.f );
+  actor.SetSize( controlSize );
+
+  Stage::GetCurrent().Add( actor );
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+
+  Property::Map map = actor.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+  Property::Value* value = map.Find( DevelImageVisual::Property::LOOP_COUNT );
+  DALI_TEST_EQUALS( value->Get< int >(), 3, TEST_LOCATION );
+
+  value = map.Find( DevelImageVisual::Property::PLAY_RANGE );
+  DALI_TEST_EQUALS( value->Get< Vector2 >(), playRange, TEST_LOCATION );
+
+  Vector2 newPlayRange( 0.4f, 1.0f );
+
+  Property::Map attributes;
+  attributes.Add( DevelImageVisual::Property::PLAY_RANGE, newPlayRange );
+  attributes.Add( DevelImageVisual::Property::LOOP_COUNT, 5 );
+
+  DevelControl::DoAction( actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY, attributes );
+
+  application.SendNotification();
+  application.Render();
+
+  map = actor.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+  value = map.Find( DevelImageVisual::Property::LOOP_COUNT );
+  DALI_TEST_EQUALS( value->Get< int >(), 5, TEST_LOCATION );
+
+  value = map.Find( DevelImageVisual::Property::PLAY_RANGE );
+  DALI_TEST_EQUALS( value->Get< Vector2 >(), newPlayRange, TEST_LOCATION );
+
+  END_TEST;
+}

diff --git a/dali-toolkit/devel-api/visuals/animated-vector-image-visual-actions-devel.h b/dali-toolkit/devel-api/visuals/animated-vector-image-visual-actions-devel.h
index 1f05bd7..92d4e8e 100644 (file)
--- a/dali-toolkit/devel-api/visuals/animated-vector-image-visual-actions-devel.h
+++ b/dali-toolkit/devel-api/visuals/animated-vector-image-visual-actions-devel.h
@@ -37,9 +37,11 @@ namespace Action
  */
 enum Type
 {
-  PLAY,        ///< Play the animated vector image.
-  PAUSE,       ///< Pause the animated vector image.
-  STOP         ///< Stop the animated vector image. This is also Default playback mode.
+  PLAY,            ///< Play the animated vector image.
+  PAUSE,           ///< Pause the animated vector image.
+  STOP,            ///< Stop the animated vector image. This is also Default playback mode.
+  JUMP_TO,         ///< Jump to the specified frame. Property::FLOAT value should be passed.
+  UPDATE_PROPERTY  ///< Update the properties of the animated vector image.
 };
 
 } // namespace Action

diff --git a/dali-toolkit/devel-api/visuals/image-visual-properties-devel.h b/dali-toolkit/devel-api/visuals/image-visual-properties-devel.h
index 2ae2726..d48eea8 100644 (file)
--- a/dali-toolkit/devel-api/visuals/image-visual-properties-devel.h
+++ b/dali-toolkit/devel-api/visuals/image-visual-properties-devel.h
@@ -99,8 +99,14 @@ enum Type
    * @details Name "playState", type PlayState (Property::INTEGER)
    * @note This property is read-only.
    */
-  PLAY_STATE = ORIENTATION_CORRECTION + 5
+  PLAY_STATE = ORIENTATION_CORRECTION + 5,
 
+  /**
+   * @brief The animation progress the AnimatedVectorImageVisual will use.
+   * @details Name "currentProgress", Type Property::FLOAT, between [0, 1] or between the play range if specified
+   * @note This property is read-only.
+   */
+  CURRENT_PROGRESS = ORIENTATION_CORRECTION + 6
 };
 
 } //namespace Property

diff --git a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp
index dbbb619..886485b 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp
+++ b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp
@@ -45,8 +45,17 @@ namespace Internal
 namespace
 {
 
+constexpr auto LOOP_FOREVER = -1;
+
 const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
 
+// Flags for re-sending data to the rasterize thread
+enum Flags
+{
+  RESEND_PLAY_RANGE  = 1 << 0,
+  RESEND_LOOP_COUNT  = 1 << 1
+};
+
 } // unnamed namespace
 
 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
@@ -70,7 +79,10 @@ AnimatedVectorImageVisual::AnimatedVectorImageVisual( VisualFactoryCache& factor
   mUrl( imageUrl ),
   mVectorRasterizeThread( imageUrl.GetUrl() ),
   mVisualSize(),
+  mPlayRange( 0.0f, 1.0f ),
   mPlacementActor(),
+  mLoopCount( LOOP_FOREVER ),
+  mResendFlag( 0 ),
   mActionStatus( DevelAnimatedVectorImageVisual::Action::STOP )
 {
   // the rasterized image is with pre-multiplied alpha format
@@ -99,9 +111,10 @@ void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const
   {
     map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
   }
-  map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast< int >( mVectorRasterizeThread.GetLoopCount() ) );
-  map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, static_cast< Vector2 >( mVectorRasterizeThread.GetPlayRange() ) );
+  map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, mLoopCount );
+  map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, mPlayRange );
   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int >( mVectorRasterizeThread.GetPlayState() ) );
+  map.Insert( Toolkit::DevelImageVisual::Property::CURRENT_PROGRESS, mVectorRasterizeThread.GetCurrentProgress() );
 }
 
 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
@@ -142,7 +155,8 @@ void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Prop
       int32_t loopCount;
       if( value.Get( loopCount ) )
       {
-        mVectorRasterizeThread.SetLoopCount( loopCount );
+        mLoopCount = loopCount;
+        mResendFlag |= RESEND_LOOP_COUNT;
       }
       break;
     }
@@ -151,7 +165,8 @@ void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Prop
       Vector2 range;
       if( value.Get( range ) )
       {
-        mVectorRasterizeThread.SetPlayRange( range );
+        mPlayRange = range;
+        mResendFlag |= RESEND_PLAY_RANGE;
       }
       break;
     }
@@ -229,6 +244,8 @@ void AnimatedVectorImageVisual::OnSetTransform()
       mVectorRasterizeThread.SetSize( width, height );
     }
 
+    SendAnimationData();
+
     if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
     {
       mVectorRasterizeThread.PlayAnimation();
@@ -294,6 +311,26 @@ void AnimatedVectorImageVisual::OnDoAction( const Property::Index actionId, cons
       mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
       break;
     }
+    case DevelAnimatedVectorImageVisual::Action::JUMP_TO:
+    {
+      float progress;
+      if( attributes.Get( progress ) )
+      {
+        mVectorRasterizeThread.SetCurrentProgress( progress );
+      }
+      break;
+    }
+    case DevelAnimatedVectorImageVisual::Action::UPDATE_PROPERTY:
+    {
+      Property::Map* map = attributes.GetMap();
+      if( map )
+      {
+        DoSetProperties( *map );
+
+        SendAnimationData();
+      }
+      break;
+    }
   }
 }
 
@@ -306,9 +343,9 @@ void AnimatedVectorImageVisual::OnResourceReady()
     actor.AddRenderer( mImpl->mRenderer );
     // reset the weak handle so that the renderer only get added to actor once
     mPlacementActor.Reset();
-  }
 
-  ResourceReady( Toolkit::Visual::ResourceStatus::READY );
+    ResourceReady( Toolkit::Visual::ResourceStatus::READY );
+  }
 }
 
 void AnimatedVectorImageVisual::OnAnimationFinished()
@@ -326,6 +363,41 @@ void AnimatedVectorImageVisual::OnAnimationFinished()
   }
 }
 
+void AnimatedVectorImageVisual::SendAnimationData()
+{
+  if( mResendFlag )
+  {
+    bool isPlaying = false;
+    if( mVectorRasterizeThread.GetPlayState() == DevelImageVisual::PlayState::PLAYING )
+    {
+      mVectorRasterizeThread.PauseAnimation();
+      isPlaying = true;
+    }
+
+    if( mResendFlag & RESEND_LOOP_COUNT )
+    {
+      mVectorRasterizeThread.SetLoopCount( mLoopCount );
+    }
+
+    if( mResendFlag & RESEND_PLAY_RANGE )
+    {
+      mVectorRasterizeThread.SetPlayRange( mPlayRange );
+    }
+
+    if( isPlaying )
+    {
+      mVectorRasterizeThread.PlayAnimation();
+    }
+    else
+    {
+      mVectorRasterizeThread.RenderFrame();
+      Stage::GetCurrent().KeepRendering( 0.0f );
+    }
+
+    mResendFlag = 0;
+  }
+}
+
 } // namespace Internal
 
 } // namespace Toolkit

diff --git a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h
index 5d871f0..032bea2 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h
+++ b/dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h
@@ -156,6 +156,11 @@ private:
    */
   void OnAnimationFinished();
 
+  /**
+   * @brief Send animation data to the rasterize thread.
+   */
+  void SendAnimationData();
+
   // Undefined
   AnimatedVectorImageVisual( const AnimatedVectorImageVisual& visual ) = delete;
 
@@ -167,7 +172,10 @@ private:
   VisualUrl                                    mUrl;
   VectorRasterizeThread                        mVectorRasterizeThread;
   Vector2                                      mVisualSize;
+  Vector2                                      mPlayRange;
   WeakHandle< Actor >                          mPlacementActor;
+  int32_t                                      mLoopCount;
+  uint32_t                                     mResendFlag;
   DevelAnimatedVectorImageVisual::Action::Type mActionStatus;
 };
 

diff --git a/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.cpp b/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.cpp
index 35f485f..49477ea 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.cpp
+++ b/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.cpp
@@ -132,13 +132,6 @@ void VectorRasterizeThread::PlayAnimation()
   ConditionalWait::ScopedLock lock( mConditionalWait );
   if( mPlayState != DevelImageVisual::PlayState::PLAYING )
   {
-    if( mPlayState == DevelImageVisual::PlayState::STOPPED )
-    {
-      // Reset the current frame and the current loop
-      mCurrentFrame = mStartFrame;
-      mCurrentLoop = 0;
-    }
-
     mPlayState = DevelImageVisual::PlayState::PLAYING;
     mConditionalWait.Notify( lock );
 
@@ -153,6 +146,10 @@ void VectorRasterizeThread::StopAnimation()
   {
     mPlayState = DevelImageVisual::PlayState::STOPPED;
 
+    // Reset the current frame and the current loop
+    mCurrentFrame = mStartFrame;
+    mCurrentLoop = 0;
+
     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::StopAnimation: Stop\n" );
   }
 }
@@ -171,10 +168,14 @@ void VectorRasterizeThread::PauseAnimation()
 void VectorRasterizeThread::RenderFrame()
 {
   ConditionalWait::ScopedLock lock( mConditionalWait );
-  mNeedRender = true;
-  mConditionalWait.Notify( lock );
 
-  DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::RenderFrame: Render\n" );
+  if( !mResourceReady )
+  {
+    mNeedRender = true;
+    mConditionalWait.Notify( lock );
+
+    DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::RenderFrame: Render\n" );
+  }
 }
 
 void VectorRasterizeThread::SetResourceReadyCallback( EventThreadCallback* callback )
@@ -191,13 +192,15 @@ void VectorRasterizeThread::SetAnimationFinishedCallback( EventThreadCallback* c
 
 void VectorRasterizeThread::SetLoopCount( int32_t count )
 {
-  ConditionalWait::ScopedLock lock( mConditionalWait );
+  if( mLoopCount != count )
+  {
+    ConditionalWait::ScopedLock lock( mConditionalWait );
 
-  mLoopCount = count;
+    mLoopCount = count;
 
-  // Reset progress
-  mCurrentLoop = 0;
-  mCurrentFrame = mStartFrame;
+    // Reset progress
+    mCurrentLoop = 0;
+  }
 }
 
 int32_t VectorRasterizeThread::GetLoopCount() const
@@ -207,8 +210,6 @@ int32_t VectorRasterizeThread::GetLoopCount() const
 
 void VectorRasterizeThread::SetPlayRange( Vector2 range )
 {
-  ConditionalWait::ScopedLock lock( mConditionalWait );
-
   // Make sure the range specified is between 0.0 and 1.0
   if( range.x >= 0.0f && range.x <= 1.0f && range.y >= 0.0f && range.y <= 1.0f )
   {
@@ -219,12 +220,31 @@ void VectorRasterizeThread::SetPlayRange( Vector2 range )
       orderedRange = Vector2( range.y, range.x );
     }
 
-    mPlayRange = orderedRange;
-
-    if( mTotalFrame != 0 )
+    if( mPlayRange != orderedRange )
     {
-      mStartFrame = static_cast< uint32_t >( mPlayRange.x * mTotalFrame + 0.5f );
-      mEndFrame = static_cast< uint32_t >( mPlayRange.y * mTotalFrame + 0.5f );
+      ConditionalWait::ScopedLock lock( mConditionalWait );
+
+      mPlayRange = orderedRange;
+
+      if( mTotalFrame != 0 )
+      {
+        mStartFrame = static_cast< uint32_t >( mPlayRange.x * mTotalFrame + 0.5f );
+        mEndFrame = static_cast< uint32_t >( mPlayRange.y * mTotalFrame + 0.5f );
+
+        // If the current frame is out of the range, change the current frame also.
+        if( mStartFrame > mCurrentFrame )
+        {
+          mCurrentFrame = mStartFrame;
+
+          mResourceReady = false;
+        }
+        else if( mEndFrame < mCurrentFrame )
+        {
+          mCurrentFrame = mEndFrame;
+
+          mResourceReady = false;
+        }
+      }
     }
   }
 }
@@ -234,6 +254,30 @@ Vector2 VectorRasterizeThread::GetPlayRange() const
   return mPlayRange;
 }
 
+void VectorRasterizeThread::SetCurrentProgress( float progress )
+{
+  ConditionalWait::ScopedLock lock( mConditionalWait );
+
+  if( progress >= mPlayRange.x && progress <= mPlayRange.y )
+  {
+    mProgress = progress;
+
+    if( mTotalFrame != 0 )
+    {
+      mCurrentFrame = static_cast< uint32_t >( mTotalFrame * progress + 0.5f );
+    }
+
+    mResourceReady = false;
+
+    DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::SetCurrentProgress: progress = %f (%d)\n", progress, mCurrentFrame );
+  }
+}
+
+float VectorRasterizeThread::GetCurrentProgress() const
+{
+  return ( static_cast< float >( mCurrentFrame ) / static_cast< float >( mTotalFrame ) );
+}
+
 DevelImageVisual::PlayState VectorRasterizeThread::GetPlayState() const
 {
   return mPlayState;
@@ -269,7 +313,7 @@ bool VectorRasterizeThread::StartRender()
   mStartFrame = static_cast< uint32_t >( mPlayRange.x * mTotalFrame + 0.5f );
   mEndFrame = static_cast< uint32_t >( mPlayRange.y * mTotalFrame + 0.5f );
 
-  mCurrentFrame = mStartFrame;
+  mCurrentFrame = std::max( static_cast< uint32_t >( mTotalFrame * mProgress + 0.5f ), mStartFrame );
 
   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::StartRender: Renderer is started [%d (%d, %d)]\n", mTotalFrame, mStartFrame, mEndFrame );
 
@@ -280,6 +324,14 @@ void VectorRasterizeThread::Rasterize()
 {
   DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::Rasterize: [%d]\n", mCurrentFrame );
 
+  bool needRender, resourceReady;
+
+  {
+    ConditionalWait::ScopedLock lock( mConditionalWait );
+    needRender = mNeedRender;
+    resourceReady = mResourceReady;
+  }
+
   // Rasterize
   mVectorRenderer.Render( mCurrentFrame );
 
@@ -300,6 +352,10 @@ void VectorRasterizeThread::Rasterize()
           // Animation is finished
           mPlayState = DevelImageVisual::PlayState::STOPPED;
 
+          // Reset the current frame and the current loop
+          mCurrentFrame = mStartFrame;
+          mCurrentLoop = 0;
+
           mAnimationFinishedTrigger->Trigger();
 
           DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::Rasterize: Animation is finished\n" );
@@ -312,9 +368,12 @@ void VectorRasterizeThread::Rasterize()
     }
   }
 
-  mNeedRender = false;
+  if( needRender )
+  {
+    mNeedRender = false;
+  }
 
-  if( !mResourceReady )
+  if( !resourceReady )
   {
     DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::Rasterize: Resource ready trigger\n" );
 

diff --git a/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.h b/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.h
index f8d409b..afb71b3 100644 (file)
--- a/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.h
+++ b/dali-toolkit/internal/visuals/animated-vector-image/vector-rasterize-thread.h
@@ -142,6 +142,18 @@ public:
    */
   bool IsResourceReady() const;
 
+  /**
+   * @brief Sets the progress of the animation.
+   * @param[in] progress The new progress as a normalized value between [0,1] or between the play range if specified.
+   */
+  void SetCurrentProgress( float progress );
+
+  /**
+   * @brief Retrieves the current progress of the animation.
+   * @return The current progress as a normalized value between [0,1]
+   */
+  float GetCurrentProgress() const;
+
 protected:
 
   /**

diff --git a/dali-toolkit/internal/visuals/visual-string-constants.cpp b/dali-toolkit/internal/visuals/visual-string-constants.cpp
index e0382b3..dfa8fef 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-string-constants.cpp
+++ b/dali-toolkit/internal/visuals/visual-string-constants.cpp
@@ -100,7 +100,9 @@ const char * const RELEASE_POLICY_NAME("releasePolicy");
 const char * const ORIENTATION_CORRECTION_NAME("orientationCorrection");
 const char * const AUXILIARY_IMAGE_NAME("auxiliaryImage");
 const char * const AUXILIARY_IMAGE_ALPHA_NAME("auxiliaryImageAlpha");
-const char * const PLAY_RANGE_NAME("playRange");
+const char * const PLAY_RANGE_NAME( "playRange" );
+const char * const PLAY_STATE_NAME( "playState" );
+const char * const CURRENT_PROGRESS_NAME( "currentProgress" );
 
 // Text visual
 const char * const TEXT_PROPERTY( "text" );

diff --git a/dali-toolkit/internal/visuals/visual-string-constants.h b/dali-toolkit/internal/visuals/visual-string-constants.h
index 6ae808b..7e20d3b 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-string-constants.h
+++ b/dali-toolkit/internal/visuals/visual-string-constants.h
@@ -86,6 +86,8 @@ extern const char * const ORIENTATION_CORRECTION_NAME;
 extern const char * const AUXILLARY_IMAGE_NAME;
 extern const char * const AUXILLARY_IMAGE_ALPHA_NAME;
 extern const char * const PLAY_RANGE_NAME;
+extern const char * const PLAY_STATE_NAME;
+extern const char * const CURRENT_PROGRESS_NAME;
 
 // Text visual
 extern const char * const TEXT_PROPERTY;