dali-toolkit/internal/transition/transition-base-impl.h

   1 #ifndef DALI_TOOLKIT_INTERNAL_TRANSITION_BASE_H
   2 #define DALI_TOOLKIT_INTERNAL_TRANSITION_BASE_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali-toolkit/public-api/controls/control.h>
  23 #include <dali-toolkit/public-api/transition/transition-base.h>
  24 #include <dali-toolkit/public-api/transition/transition-set.h>
  25
  26 // EXTERNAL INCLUDES
  27 #include <dali/public-api/animation/animation.h>
  28 #include <dali/public-api/object/base-object.h>
  29 #include <dali/public-api/object/property-map.h>
  30
  31 namespace Dali
  32 {
  33 namespace Toolkit
  34 {
  35 namespace Internal
  36 {
  37 using TransitionBasePtr = IntrusivePtr<TransitionBase>;
  38
  39 class TransitionBase : public BaseObject
  40 {
  41 public:
  42   /**
  43    * @brief Create a new TransitionBase object.
  44    * @return A smart-pointer to the newly allocated TransitionBase.
  45    */
  46   static TransitionBasePtr New();
  47
  48   /**
  49    * @copydoc Dali::Toolkit::TransitionBase::SetTimePeriod()
  50    */
  51   void SetTimePeriod(const Dali::TimePeriod& timePeriod);
  52
  53   /**
  54    * @copydoc Dali::Toolkit::TransitionBase::GetTimePeriod()
  55    */
  56   Dali::TimePeriod GetTimePeriod() const;
  57
  58   /**
  59    * @copydoc Dali::Toolkit::TransitionBase::SetAlphaFunction()
  60    */
  61   void SetAlphaFunction(AlphaFunction alphaFunction)
  62   {
  63     mAlphaFunction = alphaFunction;
  64   }
  65
  66   /**
  67    * @copydoc Dali::Toolkit::TransitionBase::GetAlphaFunction()
  68    */
  69   AlphaFunction GetAlphaFunction() const
  70   {
  71     return mAlphaFunction;
  72   }
  73
  74   /**
  75    * @copydoc Dali::Toolkit::TransitionBase::TransitionWithChild()
  76    */
  77   void TransitionWithChild(bool transitionWithChild);
  78
  79   /**
  80    * @brief Run processes those are required done before size/position negotiation.
  81    * @param[in] animation animation for the transition
  82    */
  83   void PreProcess(Dali::Animation animation);
  84
  85   /**
  86    * @brief Make property animation for Transition
  87    */
  88   void Play();
  89
  90   /**
  91    * Emit the Finished signal
  92    */
  93   void TransitionFinished();
  94
  95   /**
  96    * @brief Set this transition is appearing transition or not.
  97    * @param[in] appearingTransition True if this transition is appearing transition.
  98    */
  99   void SetAppearingTransition(bool appearingTransition)
 100   {
 101     mIsAppearingTransition = appearingTransition;
 102   }
 103
 104 protected:
 105
 106   /**
 107    * @brief Set property map which will be used as a animation start properties.
 108    * @param[in] propertyMap propertyMap that will be used as a start value of transition.
 109    */
 110   void SetStartPropertyMap(const Property::Map& propertyMap)
 111   {
 112     mStartPropertyMap = propertyMap;
 113   }
 114
 115   /**
 116    * @brief Set property map which will be used as a animation finish properties.
 117    * @param[in] propertyMap propertyMap that will be used as a finish value of transition.
 118    */
 119   void SetFinishPropertyMap(const Property::Map& propertyMap)
 120   {
 121     mFinishPropertyMap = propertyMap;
 122   }
 123
 124   /**
 125    * @brief Retrieve animation.
 126    */
 127   Dali::Animation GetAnimation()
 128   {
 129     return mAnimation;
 130   }
 131
 132   /**
 133    * @brief Set target which will be transition.
 134    * @param[in] target control that will be transition.
 135    */
 136   void SetTarget(Dali::Toolkit::Control target)
 137   {
 138     mTarget = target;
 139   }
 140
 141   /**
 142    * @brief Gets world transform of input Actor.
 143    * @param[in] actor actor for get world transform.
 144    */
 145   Matrix GetWorldTransform(Dali::Actor actor);
 146
 147   /**
 148    * @brief Gets world color of input Actor.
 149    * @param[in] actor actor for get world color.
 150    */
 151   Vector4 GetWorldColor(Dali::Actor actor);
 152
 153   /**
 154    * @brief Returns whether this transition will be applied to children of target or not.
 155    */
 156   bool IsTransitionWithChild() const
 157   {
 158     return mTransitionWithChild;
 159   }
 160
 161   /**
 162    * @brief Returns whether this transition is appearing transition or not
 163    */
 164   bool IsAppearingTransition() const
 165   {
 166     return mIsAppearingTransition;
 167   }
 168
 169   /**
 170    * @brief Set whether this transition is a transition from a Control to another Control or effect to appearing or disappearing.
 171    * @param[in] pairTransition True if this transition is appearing transition.
 172    */
 173   void SetPairTransition(bool pairTransition)
 174   {
 175     mIsPairTransition = pairTransition;
 176   }
 177
 178   /**
 179    * @brief Returns whether this transition is a transition from a Control to another Control or effect to appearing or disappearing.
 180    */
 181   bool IsPairTransition() const
 182   {
 183     return mIsPairTransition;
 184   }
 185
 186 protected:
 187   /**
 188    * Construct a new TransitionBase.
 189    */
 190   TransitionBase();
 191
 192   /**
 193    * Second-phase constructor.
 194    */
 195   void Initialize();
 196
 197   /**
 198    * Destructor
 199    */
 200   ~TransitionBase() = default;
 201
 202 private:
 203   // Undefined
 204   TransitionBase(const TransitionBase&);
 205
 206   // Undefined
 207   TransitionBase& operator=(const TransitionBase& rhs);
 208
 209 private:
 210   /**
 211    * @brief Makes property animation for transition.
 212    */
 213   void SetAnimation();
 214
 215   /**
 216    * @brief Adds a property on an animation between sourceValue and destimationValue.
 217    * @param[in] target target control to be animated.
 218    * @param[in] index property index for animation.
 219    * @param[in] sourceValue source value of animation.
 220    * @param[in] destinationValue destination value of animation.
 221    */
 222   void AnimateBetween(Dali::Toolkit::Control target, Property::Index index, Property::Value sourceValue, Property::Value destinationValue);
 223
 224   /**
 225    * @brief Copy target to make clone for the child Actors
 226    */
 227   void CopyTarget();
 228
 229   /**
 230    * @brief Make pair of Property::Map to be used for transition animation.
 231    * Set the pair of Property::Map by using SetStartPropertyMap() and SetFinishPropertyMap(),
 232    * then the properties of mTarget will be animated between them during transition duration.
 233    * If the transition requires the information of world transform, let them be in this method.
 234    * World transform and World color can be retrieved by using GetWorldTransform() and GetWorldColor() methods.
 235    * And If it is needed to add additional custom animation than use GetAnimation() and add them.
 236    *
 237    * @note Do not set any properties in this methods.
 238    */
 239   virtual void OnPlay()
 240   {
 241   }
 242
 243   /**
 244    * @brief If the transition is needed to do something after the transition is finished, let them be in this method.
 245    */
 246   virtual void OnFinished()
 247   {
 248   }
 249
 250 private:
 251   Dali::Toolkit::Control       mTarget;              ///< Target that will be animated.
 252   Dali::Actor                  mCopiedActor;         ///< Copied View that will replace mTarget during transition
 253   Dali::Animation              mAnimation;           ///< Property animations for the transition of mTarget
 254   AlphaFunction                mAlphaFunction;       ///< Alpha function that will applied for the property animation
 255   Property::Map                mStartPropertyMap;    ///< Start properties to be animated. (world transform)
 256   Property::Map                mFinishPropertyMap;   ///< Finish properties to be animated. (world transform)
 257   Property::Map                mOriginalPropertyMap; ///< Original properties of mTarget to be used to restore after the transition is finished.
 258   Dali::TimePeriod             mTimePeriod;          ///< TimePeriod of transition
 259   bool                         mTransitionWithChild; ///< True, if mTarget transition is inherit to its child Actors.
 260                                                      ///< If this is false, the child Actors are moved to the child of mCopiedActor that will have original properties of target Actor during Transition.
 261   bool mMoveTargetChildren;                          ///< Flag, if mTransitionWithChild is false and mTarget has children than True.
 262   bool mIsAppearingTransition;                       ///< True, if this transition is appearing transition.
 263   bool mIsPairTransition;                            ///< True, if this transition is started from a Control to another Control.
 264 };
 265
 266 } // namespace Internal
 267
 268 // Helpers for public-api forwarding methods
 269
 270 inline Internal::TransitionBase& GetImplementation(Dali::Toolkit::TransitionBase& animation)
 271 {
 272   DALI_ASSERT_ALWAYS(animation && "TransitionBase handle is empty");
 273
 274   BaseObject& handle = animation.GetBaseObject();
 275
 276   return static_cast<Internal::TransitionBase&>(handle);
 277 }
 278
 279 inline const Internal::TransitionBase& GetImplementation(const Dali::Toolkit::TransitionBase& animation)
 280 {
 281   DALI_ASSERT_ALWAYS(animation && "TransitionBase handle is empty");
 282
 283   const BaseObject& handle = animation.GetBaseObject();
 284
 285   return static_cast<const Internal::TransitionBase&>(handle);
 286 }
 287
 288 } // namespace Toolkit
 289
 290 } // namespace Dali
 291
 292 #endif // DALI_TOOLKIT_INTERNAL_TRANSITION_BASE_H