src/ui/animations/FUiAnim_TransactionNode.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        FUiAnim_TransactionNode.h
  20  * @brief       This is the header file for the _TransactionNode class.
  21  *
  22  * This header file contains the declarations of the _TransactionNode class.
  23  */
  24
  25 #ifndef _FUI_ANIM_INTERNAL_TRANSACTION_NODE_H_
  26 #define _FUI_ANIM_INTERNAL_TRANSACTION_NODE_H_
  27
  28 #include <FBaseErrorDefine.h>
  29 #include <FBaseColArrayList.h>
  30 #include <FBaseColHashMapT.h>
  31
  32 #include "FUiAnim_VisualElementAnimationImpl.h"
  33 #include "FUiAnim_Debug.h"
  34
  35 #include "FUiAnim_VariantEx.h"
  36
  37
  38 namespace Tizen { namespace Ui { namespace Animations
  39 {
  40
  41 class IAnimationTransactionEventListener;
  42
  43 class _AnimationTime
  44 {
  45 public:
  46         static unsigned int GetTime(bool loopTime = false);
  47 };              // _AnimationTime
  48
  49 class _AnimationData
  50         : public Tizen::Base::Object
  51 {
  52 public:
  53         enum _AnimationStatus
  54         {
  55                 _STATUS_READY,
  56                 _STATUS_START,
  57                 _STATUS_RUNNING,
  58                 _STATUS_REPEAT,
  59                 _STATUS_STOP,
  60                 _STATUS_END
  61         };
  62
  63         enum _PendingMode
  64         {
  65                 _PENDING_MODE_NONE,
  66                 _PENDING_MODE_ADD,
  67                 _PENDING_MODE_REMOVING,
  68                 _PENDING_MODE_REMOVE
  69         };
  70
  71         _AnimationData(VisualElement& target, const Tizen::Base::String* pName, VisualElementAnimation& animation);
  72         virtual ~_AnimationData(void);
  73
  74 public:
  75         VisualElementAnimation& GetAnimation(void) const;
  76         Tizen::Base::String GetName(void) const;
  77         VisualElement& GetTarget(void) const;
  78
  79         result SetBaseTime(unsigned int baseTime);
  80
  81         void SetStatus(_AnimationStatus status) { __status = status; }
  82         _AnimationStatus GetStatus(void) const { return __status; }
  83
  84         void SetPendingMode(_PendingMode mode) { __pendingMode = mode; }
  85         _PendingMode GetPendingMode(void) const { return __pendingMode; }
  86
  87         bool IsRemoved(void) const;
  88
  89         void FillValueForProperty(void);
  90
  91         Variant CalculateValueByTime(unsigned int currentTime);
  92
  93         void NotifyAnimationStatus(bool completed);
  94         void NotifyAnimationFinished(bool completed);
  95
  96         void OnTickOccurred(VisualElement& target, const Tizen::Ui::Variant& currentValue);
  97
  98 private:
  99         _AnimationData(void);
 100         _AnimationData(const _AnimationData&);
 101         _AnimationData& operator =(const _AnimationData&);
 102
 103         Variant CalculateValue(void);
 104
 105 private:
 106         VisualElement& __target;
 107         Tizen::Base::String __name;
 108         VisualElementAnimation& __animation;
 109
 110         _VariantEx __startValue;
 111         _VariantEx __endValue;
 112
 113         unsigned int __totalDuration;
 114         unsigned int __baseTime;
 115         long __currentRepeatCount;
 116         int __keyFrameIndex;
 117
 118         bool __forward;
 119         float __progress;
 120
 121         _AnimationStatus __status;
 122
 123         _PendingMode __pendingMode;
 124
 125 #ifdef  VE_DEBUG_MODULE
 126         unsigned int __tick;
 127 #endif
 128 };              // _AnimationData
 129
 130 class _TransactionNode
 131         : public _VisualElementAnimationImpl
 132 {
 133 public:
 134         enum _TransactionStatus
 135         {
 136                 _STATUS_READY,
 137                 _STATUS_START,
 138                 _STATUS_RUNNING,
 139                 _STATUS_REPEAT,
 140                 _STATUS_STOP,
 141                 _STATUS_END
 142         };
 143
 144         _TransactionNode(void);
 145         _TransactionNode(const _TransactionNode& node);
 146         virtual ~_TransactionNode(void);
 147
 148         virtual bool Equals(const Object& obj) const;
 149
 150         int GetId(void) const;
 151
 152         _TransactionNode* GetParent(void) const;
 153         result SetParent(_TransactionNode& parent);
 154
 155         result SetDefaultEventListener(const IAnimationTransactionEventListener* pListener);
 156
 157         IAnimationTransactionEventListener* GetEventListener(void) const;
 158         result SetEventListener(const IAnimationTransactionEventListener* pListener);
 159
 160         bool IsImplicitAnimationEnabled(void) const;
 161         result SetImplicitAnimationEnabled(bool enable);
 162
 163         int GetChildrenCount(void) const;
 164         _TransactionNode* GetChild(int transactionId) const;
 165         _TransactionNode* GetLastChild(void) const;
 166
 167         result AddChild(_TransactionNode& child);
 168         void RemoveChild(int transactionId);
 169         void RemoveChild(_TransactionNode& child);
 170
 171         int GetAnimationCount(void) const;
 172         result AddAnimation(VisualElement& target, const Tizen::Base::String* pKeyName, VisualElementAnimation& animation);
 173         result RemoveChildrenAnimation(VisualElement& target, const Tizen::Base::String& keyName);
 174         void RemoveChildrenAnimationByProperty(VisualElement& target, const Tizen::Base::String& property);
 175         void RemoveChildrenAllAnimations(VisualElement& target);
 176
 177         const VisualElementAnimation* GetChildrenAnimation(VisualElement& target, const Tizen::Base::String& keyName) const;
 178         const VisualElementAnimation* GetChildrenAnimationByProperty(VisualElement& target, const Tizen::Base::String& property) const;
 179
 180         void SetChildrenBaseTime(unsigned int baseTime, bool self = true);
 181
 182         virtual void Commit(void);
 183         bool IsCommitted(bool ancestors = false) const;
 184
 185         bool IsEmpty(void) const;
 186
 187         bool IsRunning(void) const;
 188         virtual bool IsRemovable(void) const;
 189
 190         virtual void NotifyTransactionStatus(bool completed);
 191
 192         void ProcessAnimationTick(unsigned int tick);
 193
 194 private:
 195         _TransactionNode& operator =(const _TransactionNode& rhs);
 196
 197         void RemoveAll(void);
 198
 199         result AddAnimationData(_AnimationData& animationData);
 200         void RemoveAnimationData(_AnimationData& animationData);
 201         result SetAnimationDataAsPending(_AnimationData& animationData, bool remove, bool completed = false);
 202
 203         _AnimationData* GetAnimationDataInPending(VisualElement& target, const Tizen::Base::String& keyName) const;
 204         _AnimationData* GetAnimationDataInPendingByProperty(VisualElement& target, const Tizen::Base::String& property) const;
 205
 206         result RemoveAnimation(VisualElement& target, const Tizen::Base::String& keyName);
 207         void RemoveAnimationByProperty(VisualElement& target, const Tizen::Base::String& property);
 208         void RemoveAllAnimations(void);
 209         void RemoveAllAnimations(VisualElement& target);
 210
 211         const VisualElementAnimation* GetAnimation(VisualElement& target, const Tizen::Base::String& property) const;
 212         const VisualElementAnimation* GetAnimationByProperty(VisualElement& target, const Tizen::Base::String& property) const;
 213
 214         void SetBaseTime(unsigned int baseTime);
 215
 216         void ReservedRemove(bool remove = true);
 217         bool IsReservedRemove(void) const;
 218
 219         virtual void CalculateProgress(unsigned int currentTime);
 220
 221         bool RemoveAnimationByDuplicatedProperty(_AnimationData& animationData);
 222
 223         bool IsInAnimationTick(void);
 224         void ProcessPendingAnimations(void);
 225         void OnAnimationTick(unsigned int tick);
 226
 227 protected:
 228         int __id;
 229
 230         _TransactionNode* __pParent;
 231         _TransactionNode* __pRoot;
 232
 233         IAnimationTransactionEventListener* __pDefaultListener;
 234         IAnimationTransactionEventListener* __pListener;
 235
 236         bool __isImplicitAnimationEnabled;
 237
 238         bool __isCommitted;
 239         bool __isReservedRemove;
 240         bool __isInAnimationTick;
 241
 242         _TransactionStatus __status;
 243
 244         unsigned int __baseTime;
 245         unsigned int __adjustedBaseTime;
 246         long __currentRepeatCount;
 247
 248         Tizen::Base::Collection::ArrayList __children;
 249         Tizen::Base::Collection::ArrayList __pendingAnimations;
 250         Tizen::Base::Collection::HashMapT<VisualElement*, Tizen::Base::Collection::ArrayList*> __animations;
 251 };              // _TransactionNode
 252
 253 class _AnimationGroupNode
 254         : public _TransactionNode
 255 {
 256 public:
 257         _AnimationGroupNode(VisualElement& target, const Tizen::Base::String* pName, VisualElementAnimation& animation);
 258         virtual ~_AnimationGroupNode(void);
 259
 260         VisualElementAnimation& GetAnimation(void) const;
 261         bool IsEqual(VisualElement& target, const Tizen::Base::String& keyName) const;
 262
 263         virtual void Commit(void);
 264
 265         virtual bool IsRemovable(void) const;
 266
 267         virtual void NotifyTransactionStatus(bool completed);
 268
 269 private:
 270         _AnimationGroupNode(void);
 271         _AnimationGroupNode(const _AnimationGroupNode& rhs);
 272         _AnimationGroupNode& operator =(const _AnimationGroupNode& rhs);
 273
 274         virtual void CalculateProgress(unsigned int currentTime);
 275
 276         VisualElement& __target;
 277         Tizen::Base::String __name;
 278         VisualElementAnimation& __animation;
 279         bool __deleteAnimation;
 280
 281         unsigned int __totalDuration;
 282         float __progress;
 283
 284 #ifdef  VE_DEBUG_MODULE
 285         unsigned int __tick;
 286 #endif
 287 };              // _AnimationGroupNode
 288
 289 }}}             // Tizen::Ui::Animations
 290
 291 #endif // _FUI_ANIM_INTERNAL_TRANSACTION_NODE_H_
 292