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) 2022 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   /**
 105    * @brief Returns whether this transition is appearing transition or not
 106    */
 107   bool IsAppearingTransition() const
 108   {
 109     return mIsAppearingTransition;
 110   }
 111
 112   /**
 113    * @brief Returns whether this transition is a transition from a Control to another Control or effect to appearing or disappearing.
 114    */
 115   bool IsPairTransition() const
 116   {
 117     return mIsPairTransition;
 118   }
 119
 120   /**
 121    * @brief Returns target which will be transition.
 122    */
 123   const Dali::Toolkit::Control GetTarget() const
 124   {
 125     return mTarget;
 126   }
 127
 128 protected:
 129   /**
 130    * @brief Set property map which will be used as a animation start properties.
 131    * @param[in] propertyMap propertyMap that will be used as a start value of transition.
 132    */
 133   void SetStartPropertyMap(const Property::Map& propertyMap)
 134   {
 135     mStartPropertyMap = propertyMap;
 136   }
 137
 138   /**
 139    * @brief Set property map which will be used as a animation finish properties.
 140    * @param[in] propertyMap propertyMap that will be used as a finish value of transition.
 141    */
 142   void SetFinishPropertyMap(const Property::Map& propertyMap)
 143   {
 144     mFinishPropertyMap = propertyMap;
 145   }
 146
 147   /**
 148    * @brief Retrieve animation.
 149    */
 150   Dali::Animation GetAnimation()
 151   {
 152     return mAnimation;
 153   }
 154
 155   /**
 156    * @brief Set target which will be transition.
 157    * @param[in] target control that will be transition.
 158    */
 159   void SetTarget(Dali::Toolkit::Control target)
 160   {
 161     mTarget = target;
 162   }
 163
 164   /**
 165    * @brief Returns whether this transition will be applied to children of target or not.
 166    */
 167   bool IsTransitionWithChild() const
 168   {
 169     return mTransitionWithChild;
 170   }
 171
 172   /**
 173    * @brief Set whether this transition is a transition from a Control to another Control or effect to appearing or disappearing.
 174    * @param[in] pairTransition True if this transition is appearing transition.
 175    */
 176   void SetPairTransition(bool pairTransition)
 177   {
 178     mIsPairTransition = pairTransition;
 179   }
 180
 181 protected:
 182   /**
 183    * Construct a new TransitionBase.
 184    */
 185   TransitionBase();
 186
 187   /**
 188    * Second-phase constructor.
 189    */
 190   void Initialize();
 191
 192   /**
 193    * Destructor
 194    */
 195   ~TransitionBase() = default;
 196
 197 private:
 198   // Undefined
 199   TransitionBase(const TransitionBase&);
 200
 201   // Undefined
 202   TransitionBase& operator=(const TransitionBase& rhs);
 203
 204 private:
 205   /**
 206    * @brief Makes property animation for transition.
 207    */
 208   void SetAnimation();
 209
 210   /**
 211    * @brief Adds a property on an animation between sourceValue and destimationValue.
 212    * @param[in] target target control to be animated.
 213    * @param[in] index property index for animation.
 214    * @param[in] sourceValue source value of animation.
 215    * @param[in] destinationValue destination value of animation.
 216    */
 217   void AnimateBetween(Dali::Toolkit::Control target, Property::Index index, Property::Value sourceValue, Property::Value destinationValue);
 218
 219   /**
 220    * @brief Copy target to make clone for the child Actors
 221    */
 222   void CopyTarget();
 223
 224   /**
 225    * @brief Make pair of Property::Map to be used for transition animation.
 226    * Set the pair of Property::Map by using SetStartPropertyMap() and SetFinishPropertyMap(),
 227    * then the properties of mTarget will be animated between them during transition duration.
 228    * If the transition requires the information of world transform, let them be in this method.
 229    * World transform and World color can be retrieved by using GetWorldTransform() and GetWorldColor() methods.
 230    * And If it is needed to add additional custom animation than use GetAnimation() and add them.
 231    *
 232    * @note Do not set any properties in this methods.
 233    */
 234   virtual void OnPlay()
 235   {
 236   }
 237
 238   /**
 239    * @brief If the transition is needed to do something after the transition is finished, let them be in this method.
 240    */
 241   virtual void OnFinished()
 242   {
 243   }
 244
 245 private:
 246   Dali::Toolkit::Control mTarget;              ///< Target that will be animated.
 247   Dali::Actor            mCopiedActor;         ///< Copied View that will replace mTarget during transition
 248   Dali::Animation        mAnimation;           ///< Property animations for the transition of mTarget
 249   AlphaFunction          mAlphaFunction;       ///< Alpha function that will applied for the property animation
 250   Property::Map          mStartPropertyMap;    ///< Start properties to be animated. (world transform)
 251   Property::Map          mFinishPropertyMap;   ///< Finish properties to be animated. (world transform)
 252   Property::Map          mOriginalPropertyMap; ///< Original properties of mTarget to be used to restore after the transition is finished.
 253   Dali::TimePeriod       mTimePeriod;          ///< TimePeriod of transition
 254   bool                   mTransitionWithChild; ///< True, if mTarget transition is inherit to its child Actors.
 255                                                ///< If this is false, the child Actors are moved to the child of mCopiedActor that will have original properties of target Actor during Transition.
 256   bool mMoveTargetChildren;                    ///< Flag, if mTransitionWithChild is false and mTarget has children than True.
 257   bool mIsAppearingTransition;                 ///< True, if this transition is appearing transition.
 258   bool mIsPairTransition;                      ///< True, if this transition is started from a Control to another Control.
 259 };
 260
 261 } // namespace Internal
 262
 263 // Helpers for public-api forwarding methods
 264
 265 inline Internal::TransitionBase& GetImplementation(Dali::Toolkit::TransitionBase& animation)
 266 {
 267   DALI_ASSERT_ALWAYS(animation && "TransitionBase handle is empty");
 268
 269   BaseObject& handle = animation.GetBaseObject();
 270
 271   return static_cast<Internal::TransitionBase&>(handle);
 272 }
 273
 274 inline const Internal::TransitionBase& GetImplementation(const Dali::Toolkit::TransitionBase& animation)
 275 {
 276   DALI_ASSERT_ALWAYS(animation && "TransitionBase handle is empty");
 277
 278   const BaseObject& handle = animation.GetBaseObject();
 279
 280   return static_cast<const Internal::TransitionBase&>(handle);
 281 }
 282
 283 } // namespace Toolkit
 284
 285 } // namespace Dali
 286
 287 #endif // DALI_TOOLKIT_INTERNAL_TRANSITION_BASE_H