dali-toolkit/internal/transition/transition-set-impl.cpp

   1 /*
   2  * Copyright (c) 2021 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-toolkit/internal/transition/transition-set-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/adaptor-framework/adaptor.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/public-api/object/type-registry.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/transition/transition-lifecycle-controller.h>
  28
  29 namespace Dali
  30 {
  31 namespace Toolkit
  32 {
  33 namespace Internal
  34 {
  35 namespace
  36 {
  37 // Signals
  38 static constexpr std::string_view SIGNAL_FINISHED = "finished";
  39
  40 BaseHandle Create()
  41 {
  42   return Dali::Toolkit::TransitionSet::New();
  43 }
  44
  45 TypeRegistration mType(typeid(Dali::Toolkit::TransitionSet), typeid(Dali::BaseHandle), Create);
  46
  47 SignalConnectorType signalConnector1(mType, std::string(SIGNAL_FINISHED), &TransitionSet::DoConnectSignal);
  48
  49 } // anonymous namespace
  50
  51 TransitionSetPtr TransitionSet::New()
  52 {
  53   TransitionSetPtr transitionSet = new TransitionSet();
  54
  55   return transitionSet;
  56 }
  57
  58 TransitionSet::TransitionSet()
  59 {
  60 }
  61
  62 TransitionSet::~TransitionSet()
  63 {
  64   mTransitions.clear();
  65 }
  66
  67 void TransitionSet::AddTransition(TransitionBasePtr transition)
  68 {
  69   mTransitions.push_back(transition);
  70 }
  71
  72 TransitionBase* TransitionSet::GetTransitionAt(uint32_t index) const
  73 {
  74   TransitionBase* result(nullptr);
  75   if(index < GetTransitionCount())
  76   {
  77     result = mTransitions[index].Get();
  78   }
  79   else
  80   {
  81     DALI_LOG_ERROR("Error: Invalid index to TransitionSet::GetTransitionAt\n");
  82   }
  83
  84   return result;
  85 }
  86
  87 uint32_t TransitionSet::GetTransitionCount() const
  88 {
  89   return mTransitions.size();
  90 }
  91
  92 void TransitionSet::Play()
  93 {
  94   Adaptor::Get().RegisterProcessor(*this, true);
  95   Adaptor::Get().RegisterProcessor(*this, false);
  96   TransitionLifecycleController::GetInstance().AddTransitions(Dali::Toolkit::TransitionSet(this));
  97 }
  98
  99 void TransitionSet::TransitionPreProcess()
 100 {
 101   float lastDuration = 0.0f;
 102   for(auto&& transition : mTransitions)
 103   {
 104     TimePeriod timePeriod = transition->GetTimePeriod();
 105     if(lastDuration <= timePeriod.durationSeconds + timePeriod.delaySeconds)
 106     {
 107       lastDuration = timePeriod.durationSeconds + timePeriod.delaySeconds;
 108     }
 109   }
 110   mAnimation = Dali::Animation::New(lastDuration);
 111
 112   for(auto&& transition : mTransitions)
 113   {
 114     transition->PreProcess(mAnimation);
 115   }
 116 }
 117
 118 void TransitionSet::TransitionStart()
 119 {
 120   for(auto&& transition : mTransitions)
 121   {
 122     transition->Play();
 123   }
 124
 125   mAnimation.FinishedSignal().Connect(this, &TransitionSet::TransitionFinished);
 126   mAnimation.Play();
 127 }
 128
 129 void TransitionSet::TransitionFinished(Dali::Animation& source)
 130 {
 131   for(auto&& transition : mTransitions)
 132   {
 133     transition->TransitionFinished();
 134   }
 135
 136   EmitFinishedSignal();
 137 }
 138
 139 Dali::Toolkit::TransitionSet::TransitionSetSignalType& TransitionSet::FinishedSignal()
 140 {
 141   return mFinishedSignal;
 142 }
 143
 144 void TransitionSet::EmitFinishedSignal()
 145 {
 146   if(!mFinishedSignal.Empty())
 147   {
 148     Dali::Toolkit::TransitionSet handle(this);
 149     mFinishedSignal.Emit(handle);
 150   }
 151 }
 152
 153 bool TransitionSet::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
 154 {
 155   bool           connected(false);
 156   TransitionSet* transitionSet = static_cast<TransitionSet*>(object); // TypeRegistry guarantees that this is the correct type.
 157
 158   if(SIGNAL_FINISHED == signalName)
 159   {
 160     transitionSet->FinishedSignal().Connect(tracker, functor);
 161     connected = true;
 162   }
 163
 164   return connected;
 165 }
 166
 167 void TransitionSet::Process(bool postProcessor)
 168 {
 169   if(!postProcessor)
 170   {
 171     TransitionPreProcess();
 172   }
 173   else
 174   {
 175     TransitionStart();
 176   }
 177   Adaptor::Get().UnregisterProcessor(*this, postProcessor);
 178 }
 179
 180 } // namespace Internal
 181
 182 } // namespace Toolkit
 183
 184 } // namespace Dali