src/ui/animations/FUiAnim_VisualElementAnimationImpl.cpp

   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_VisualElementAnimationImpl.cpp
  20  * @brief       This file contains implementation of _VisualElementAnimationImpl class
  21  *
  22  * This file contains implementation _VisualElementAnimationImpl class.
  23  */
  24
  25 #include <FBaseSysLog.h>
  26
  27 #include <FUiAnimVisualElementAnimation.h>
  28 #include <FUiAnimIVisualElementAnimationStatusEventListener.h>
  29 #include <FUiAnimIVisualElementAnimationTimingFunction.h>
  30 #include <FUiAnimIVisualElementAnimationValueInterpolator.h>
  31
  32 #include "FUiAnim_VisualElementAnimationImpl.h"
  33 #include "FUiAnim_AnimationManager.h"
  34 #include "FUiAnim_TransactionNode.h"
  35
  36 namespace Tizen { namespace Ui { namespace Animations
  37 {
  38
  39
  40 _VisualElementAnimationImpl::_VisualElementAnimationImpl(void)
  41         : __pStatusListener(null)
  42         , __pTimingFunction(null)
  43         , __pInterpolator(null)
  44         , __pUserData(null)
  45         , __pEventTarget(null)
  46 {
  47         _TransactionNode* pNode = _AnimationManager::GetInstance()->GetCurrentTransaction(false);
  48
  49         if (pNode)
  50         {
  51                 result r = CopyAnimationValue(*pNode);
  52
  53                 SysTryReturnVoidResult(NID_UI_ANIM, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
  54         }
  55 }
  56
  57 _VisualElementAnimationImpl::_VisualElementAnimationImpl(const _VisualElementAnimationImpl& animationImpl)
  58         : __pStatusListener(null)
  59         , __pTimingFunction(null)
  60         , __pInterpolator(null)
  61         , __pUserData(null)
  62         , __pEventTarget(null)
  63 {
  64         result r = CopyAnimationValue(animationImpl);
  65
  66         SysTryReturnVoidResult(NID_UI_ANIM, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
  67 }
  68
  69 _VisualElementAnimationImpl::~_VisualElementAnimationImpl(void)
  70 {
  71
  72 }
  73
  74 bool
  75 _VisualElementAnimationImpl::Equals(const Tizen::Base::Object& obj) const
  76 {
  77         if (this == &obj)
  78         {
  79                 return true;
  80         }
  81
  82         const _VisualElementAnimationImpl* pAnimationImpl = dynamic_cast< const _VisualElementAnimationImpl* >(&obj);
  83
  84         if (pAnimationImpl == null)
  85         {
  86                 return false;
  87         }
  88
  89         return ((GetDuration() == pAnimationImpl->GetDuration())
  90                         && (GetDelay() == pAnimationImpl->GetDelay())
  91                         && (GetOffset() == pAnimationImpl->GetOffset())
  92                         && (GetRepeatCount() == pAnimationImpl->GetRepeatCount())
  93                         && (GetScaleRatio() == pAnimationImpl->GetScaleRatio())
  94                         && (IsAutoReverseEnabled() == pAnimationImpl->IsAutoReverseEnabled())
  95                         && (__pStatusListener == pAnimationImpl->__pStatusListener)
  96                         && (__pTimingFunction == pAnimationImpl->__pTimingFunction)
  97                         && (__pInterpolator == pAnimationImpl->__pInterpolator)
  98                         && (__pUserData == pAnimationImpl->__pUserData));
  99 }
 100
 101 int
 102 _VisualElementAnimationImpl::GetHashCode(void) const
 103 {
 104         return (GetDuration() + GetOffset() + GetDelay() + GetRepeatCount() + GetScaleRatio() + IsAutoReverseEnabled());
 105 }
 106
 107 result
 108 _VisualElementAnimationImpl::CopyAnimationValue(const _VisualElementAnimationImpl& animationImpl)
 109 {
 110         SetDuration(animationImpl.GetDuration());
 111         SetDelay(animationImpl.GetDelay());
 112         SetOffset(animationImpl.GetOffset());
 113         SetRepeatCount(animationImpl.GetRepeatCount());
 114         SetScaleRatio(animationImpl.GetScaleRatio());
 115         SetAutoReverseEnabled(animationImpl.IsAutoReverseEnabled());
 116
 117         __pStatusListener = animationImpl.__pStatusListener;
 118         __pTimingFunction = animationImpl.__pTimingFunction;
 119         __pInterpolator = animationImpl.__pInterpolator;
 120         __pUserData = animationImpl.__pUserData;
 121         __pEventTarget = animationImpl.__pEventTarget;
 122
 123         return E_SUCCESS;
 124 }
 125
 126 bool
 127 _VisualElementAnimationImpl::IsAnimationSupported(void)
 128 {
 129         static bool isAnimationSupported = true;
 130
 131         return isAnimationSupported;
 132 }
 133
 134 void
 135 _VisualElementAnimationImpl::SetStatusEventListener(IVisualElementAnimationStatusEventListener* pListener)
 136 {
 137         __pStatusListener = pListener;
 138 }
 139
 140 IVisualElementAnimationStatusEventListener*
 141 _VisualElementAnimationImpl::GetStatusEventListener(void) const
 142 {
 143         return __pStatusListener;
 144 }
 145
 146 void
 147 _VisualElementAnimationImpl::SetTimingFunction(const IVisualElementAnimationTimingFunction* pTimingFunction)
 148 {
 149         __pTimingFunction = pTimingFunction;
 150 }
 151
 152 const IVisualElementAnimationTimingFunction*
 153 _VisualElementAnimationImpl::GetTimingFunction(void) const
 154 {
 155         return __pTimingFunction;
 156 }
 157
 158 void
 159 _VisualElementAnimationImpl::SetValueInterpolator(const IVisualElementAnimationValueInterpolator* pInterpolator)
 160 {
 161         __pInterpolator = pInterpolator;
 162 }
 163
 164 const IVisualElementAnimationValueInterpolator*
 165 _VisualElementAnimationImpl::GetValueInterpolator(void) const
 166 {
 167         return __pInterpolator;
 168 }
 169
 170 void
 171 _VisualElementAnimationImpl::SetUserData(void* pUserData)
 172 {
 173         __pUserData = pUserData;
 174 }
 175
 176 void*
 177 _VisualElementAnimationImpl::GetUserData(void) const
 178 {
 179         return __pUserData;
 180 }
 181
 182 void
 183 _VisualElementAnimationImpl::SetEventTarget(VisualElement& target)
 184 {
 185         __pEventTarget = &target;
 186 }
 187
 188 VisualElement&
 189 _VisualElementAnimationImpl::GetEventTarget(void) const
 190 {
 191         return *__pEventTarget;
 192 }
 193
 194 _VisualElementAnimationImpl*
 195 _VisualElementAnimationImpl::GetInstance(VisualElementAnimation& animation)
 196 {
 197         return animation._pAnimationImpl;
 198 }
 199
 200 const _VisualElementAnimationImpl*
 201 _VisualElementAnimationImpl::GetInstance(const VisualElementAnimation& animation)
 202 {
 203         return static_cast<const _VisualElementAnimationImpl*>(animation._pAnimationImpl);
 204 }
 205
 206
 207 }}}   // Tizen::Ui::Animations
 208