dali/internal/event/animation/animation-playlist.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/animation/animation-playlist.h>
  20
  21
  22 // INTERNAL INCLUDES
  23 #include <dali/public-api/common/vector-wrapper.h>
  24 #include <dali/internal/event/animation/animation-impl.h>
  25
  26
  27 namespace Dali
  28 {
  29
  30 namespace Internal
  31 {
  32
  33 AnimationPlaylist* AnimationPlaylist::New()
  34 {
  35   return new AnimationPlaylist();
  36 }
  37
  38 AnimationPlaylist::AnimationPlaylist()
  39 {
  40 }
  41
  42 AnimationPlaylist::~AnimationPlaylist()
  43 {
  44 }
  45
  46 void AnimationPlaylist::AnimationCreated( Animation& animation )
  47 {
  48   mAnimations.PushBack( &animation );
  49 }
  50
  51 void AnimationPlaylist::AnimationDestroyed( Animation& animation )
  52 {
  53   Dali::Vector< Animation* >::Iterator iter = std::find( mAnimations.Begin(), mAnimations.End(), &animation );
  54   DALI_ASSERT_ALWAYS( iter != mAnimations.End() && "Animation not found" );
  55
  56   mAnimations.Remove( iter );
  57 }
  58
  59 void AnimationPlaylist::OnPlay( Animation& animation )
  60 {
  61   mPlaylist.push_back( Dali::Animation(&animation) );
  62 }
  63
  64 void AnimationPlaylist::OnClear( Animation& animation )
  65 {
  66   std::vector< Dali::Animation >::iterator iter = std::find( mPlaylist.begin(), mPlaylist.end(), Dali::Animation(&animation) );
  67   std::vector< Dali::Animation >::iterator last = mPlaylist.end();
  68   if( iter != last )
  69   {
  70     --last; // move to real last
  71     std::swap( *iter, *last ); // swap
  72     mPlaylist.resize( mPlaylist.size() - 1u );
  73   }
  74 }
  75
  76 void AnimationPlaylist::NotifyCompleted()
  77 {
  78   std::vector< Dali::Animation > finishedAnimations;
  79
  80   // Since animations can be unreferenced during the signal emissions, iterators into animationPointers may be invalidated.
  81   // First copy and reference the finished animations, then emit signals
  82   for ( Dali::Vector< Animation* >::Iterator iter = mAnimations.Begin(); iter != mAnimations.End(); ++iter )
  83   {
  84     Animation* animation = *iter;
  85
  86     if ( animation->HasFinished() )
  87     {
  88       finishedAnimations.push_back( Dali::Animation(animation) );
  89
  90       // The animation may be present in mPlaylist - remove if necessary
  91       // Note that the animation "Finish" signal is emitted after Stop() has been called
  92       std::vector< Dali::Animation >::iterator iter = std::find( mPlaylist.begin(), mPlaylist.end(), Dali::Animation(animation) );
  93       DALI_ASSERT_DEBUG(iter != mPlaylist.end());
  94       mPlaylist.erase( iter );
  95     }
  96   }
  97
  98   // Now it's safe to emit the signals
  99   for ( std::vector< Dali::Animation >::iterator iter = finishedAnimations.begin(); iter != finishedAnimations.end(); ++iter )
 100   {
 101     Dali::Animation& handle = *iter;
 102
 103     GetImplementation(handle).EmitSignalFinish();
 104   }
 105 }
 106
 107 void AnimationPlaylist::NotifyProgressReached( const SceneGraph::Animation* sceneGraphAnimation )
 108 {
 109   std::vector< Dali::Animation > notifyProgressAnimations; // Will own animations until all emits have been done
 110
 111   for ( Dali::Vector< Animation* >::Iterator iter = mAnimations.Begin(); iter != mAnimations.End(); ++iter )
 112   {
 113     Animation* animation = *iter;
 114
 115     if ( ( animation->GetSceneObject() ) == sceneGraphAnimation )
 116     {
 117       // Store handles to animations that need signals emitted in the case of an animation being cleared in-between emits
 118       notifyProgressAnimations.push_back(  Dali::Animation( animation ) );
 119     }
 120   }
 121
 122   for ( std::vector< Dali::Animation >::iterator iter = notifyProgressAnimations.begin(); iter != notifyProgressAnimations.end(); ++iter )
 123   {
 124     Dali::Animation& handle = *iter;
 125
 126     GetImplementation(handle).EmitSignalProgressReached();
 127   }
 128 }
 129
 130 } // namespace Internal
 131
 132 } // namespace Dali