mEndAction( endAction ),
mDisconnectAction( disconnectAction ),
mDefaultAlpha( defaultAlpha ),
- mState(Dali::Animation::STOPPED)
+ mState(Dali::Animation::STOPPED),
+ mProgressReachedMarker( 0.0f ),
+ mDelaySeconds( 0.0f )
{
}
{
DALI_ASSERT_DEBUG( mAnimation == NULL );
- // Create a new animation, temporarily owned
- SceneGraph::Animation* animation = SceneGraph::Animation::New( mDurationSeconds, mSpeedFactor, mPlayRange, mLoopCount, mEndAction, mDisconnectAction );
-
- // Keep a const pointer to the animation.
- mAnimation = animation;
-
- // Transfer animation ownership to the update manager through a message
- AddAnimationMessage( mEventThreadServices.GetUpdateManager(), animation );
+ // Create a new animation, Keep a const pointer to the animation.
+ mAnimation = SceneGraph::Animation::New( mDurationSeconds, mSpeedFactor, mPlayRange, mLoopCount, mEndAction, mDisconnectAction );
+ OwnerPointer< SceneGraph::Animation > transferOwnership( const_cast< SceneGraph::Animation* >( mAnimation ) );
+ AddAnimationMessage( mEventThreadServices.GetUpdateManager(), transferOwnership );
}
void Animation::DestroySceneObject()
SetDurationMessage( mEventThreadServices, *mAnimation, seconds );
}
+void Animation::SetProgressNotification( float progress )
+{
+ // mAnimation is being used in a separate thread; queue a message to set the value
+ mProgressReachedMarker = progress;
+}
+
+float Animation::GetProgressNotification()
+{
+ return mProgressReachedMarker;
+}
+
float Animation::GetDuration() const
{
// This is not animatable; the cached value is up-to-date.
mState = Dali::Animation::PLAYING;
- if( mEndAction != EndAction::Discard ) // If the animation is discarded, then we do not want to change the target values
- {
- // Sort according to end time with earlier end times coming first, if the end time is the same, then the connectors are not moved
- std::stable_sort( mConnectorTargetValues.begin(), mConnectorTargetValues.end(), CompareConnectorEndTimes );
-
- // Loop through all connector target values sorted by increasing end time
- ConnectorTargetValuesContainer::const_iterator iter = mConnectorTargetValues.begin();
- const ConnectorTargetValuesContainer::const_iterator endIter = mConnectorTargetValues.end();
- for( ; iter != endIter; ++iter )
- {
- AnimatorConnectorBase* connector = mConnectors[ iter->connectorIndex ];
+ NotifyObjects();
- Object* object = connector->GetObject();
- if( object )
- {
- object->NotifyPropertyAnimation( *this, connector->GetPropertyIndex(), iter->targetValue, iter->animatorType );
- }
- }
- }
+ SendFinalProgressNotificationMessage();
// mAnimation is being used in a separate thread; queue a Play message
PlayAnimationMessage( mEventThreadServices, *mAnimation );
mState = Dali::Animation::PLAYING;
+ NotifyObjects();
+
+ SendFinalProgressNotificationMessage();
+
// mAnimation is being used in a separate thread; queue a Play message
PlayAnimationFromMessage( mEventThreadServices, *mAnimation, progress );
}
}
+void Animation::PlayAfter( float delaySeconds )
+{
+ // The negative delay means play immediately.
+ delaySeconds = std::max( 0.f, delaySeconds );
+
+ mDelaySeconds = delaySeconds;
+
+ // Update the current playlist
+ mPlaylist.OnPlay( *this );
+
+ mState = Dali::Animation::PLAYING;
+
+ NotifyObjects();
+
+ SendFinalProgressNotificationMessage();
+
+ // mAnimation is being used in a separate thread; queue a message to set the value
+ PlayAfterMessage( mEventThreadServices, *mAnimation, delaySeconds );
+}
+
void Animation::Pause()
{
mState = Dali::Animation::PAUSED;
return mFinishedSignal;
}
+Dali::Animation::AnimationSignalType& Animation::ProgressReachedSignal()
+{
+ return mProgressReachedSignal;
+}
+
void Animation::EmitSignalFinish()
{
if ( !mFinishedSignal.Empty() )
}
}
+void Animation::EmitSignalProgressReached()
+{
+ if ( !mProgressReachedSignal.Empty() )
+ {
+ Dali::Animation handle( this );
+ mProgressReachedSignal.Emit( handle );
+ }
+}
+
bool Animation::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
return ( ( lhs.timePeriod.delaySeconds + lhs.timePeriod.durationSeconds ) < ( rhs.timePeriod.delaySeconds + rhs.timePeriod.durationSeconds ) );
}
+void Animation::NotifyObjects()
+{
+ if( mEndAction != EndAction::Discard ) // If the animation is discarded, then we do not want to change the target values
+ {
+ // Sort according to end time with earlier end times coming first, if the end time is the same, then the connectors are not moved
+ std::stable_sort( mConnectorTargetValues.begin(), mConnectorTargetValues.end(), CompareConnectorEndTimes );
+
+ // Loop through all connector target values sorted by increasing end time
+ ConnectorTargetValuesContainer::const_iterator iter = mConnectorTargetValues.begin();
+ const ConnectorTargetValuesContainer::const_iterator endIter = mConnectorTargetValues.end();
+ for( ; iter != endIter; ++iter )
+ {
+ AnimatorConnectorBase* connector = mConnectors[ iter->connectorIndex ];
+
+ Object* object = connector->GetObject();
+ if( object )
+ {
+ object->NotifyPropertyAnimation( *this, connector->GetPropertyIndex(), iter->targetValue, iter->animatorType );
+ }
+ }
+ }
+}
+
+
+void Animation::SendFinalProgressNotificationMessage()
+{
+ if ( mProgressReachedMarker > 0.0f )
+ {
+ float progressMarkerSeconds = mDurationSeconds * mProgressReachedMarker;
+ SetProgressNotificationMessage( mEventThreadServices, *mAnimation, progressMarkerSeconds );
+ }
+}
+
} // namespace Internal
} // namespace Dali