src/ui/animations/FUiAnim_VisualElementValueAnimationImpl.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_VisualElementValueAnimationImpl.cpp
  20  * @brief       This file contains implementation of _VisualElementValueAnimationImpl class
  21  *
  22  * This file contains implementation _VisualElementValueAnimationImpl class.
  23  */
  24
  25 #include <FBaseSysLog.h>
  26
  27 #include <FUiAnimVisualElementValueAnimation.h>
  28 #include <FUiAnimIVisualElementAnimationTickEventListener.h>
  29
  30 #include "FUiAnim_VisualElementAnimationKeyFrame.h"
  31 #include "FUiAnim_VisualElementValueAnimationImpl.h"
  32
  33 namespace Tizen { namespace Ui { namespace Animations
  34 {
  35
  36
  37 _VisualElementValueAnimationImpl::_VisualElementValueAnimationImpl(void)
  38         : __pTickListener(null)
  39         , __applyEndValue(true)
  40         , __pKeyFrame(null)
  41 {
  42
  43 }
  44
  45 _VisualElementValueAnimationImpl::_VisualElementValueAnimationImpl(const _VisualElementValueAnimationImpl& animationImpl)
  46         : __pTickListener(null)
  47         , __applyEndValue(true)
  48         , __pKeyFrame(null)
  49 {
  50         result r = CopyAnimationValue(animationImpl);
  51
  52         SysTryReturnVoidResult(NID_UI_ANIM, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
  53 }
  54
  55 _VisualElementValueAnimationImpl::~_VisualElementValueAnimationImpl(void)
  56 {
  57         if (__pKeyFrame)
  58         {
  59                 delete __pKeyFrame;
  60                 __pKeyFrame = null;
  61         }
  62 }
  63
  64 bool
  65 _VisualElementValueAnimationImpl::Equals(const Tizen::Base::Object& obj) const
  66 {
  67         if (this == &obj)
  68         {
  69                 return true;
  70         }
  71
  72         const _VisualElementValueAnimationImpl* pAnimationImpl = dynamic_cast< const _VisualElementValueAnimationImpl* >(&obj);
  73
  74         if (pAnimationImpl == null)
  75         {
  76                 return false;
  77         }
  78
  79         bool isKeyFrameEqual = false;
  80
  81         if (__pKeyFrame != null && pAnimationImpl->__pKeyFrame != null)
  82         {
  83                 isKeyFrameEqual = __pKeyFrame->Equals(*(pAnimationImpl->__pKeyFrame));
  84         }
  85         else if (__pKeyFrame == null && pAnimationImpl->__pKeyFrame == null)
  86         {
  87                 isKeyFrameEqual = true;
  88         }
  89
  90         return (_VisualElementAnimationImpl::Equals(obj)
  91                         && (__pTickListener == pAnimationImpl->__pTickListener)
  92                         && (__start == pAnimationImpl->__start)
  93                         && (__end == pAnimationImpl->__end)
  94                         && (__applyEndValue == pAnimationImpl->__applyEndValue)
  95                         && (isKeyFrameEqual));
  96 }
  97
  98 int
  99 _VisualElementValueAnimationImpl::GetHashCode(void) const
 100 {
 101         return (_VisualElementAnimationImpl::GetHashCode() + __start.GetHashCode() + __end.GetHashCode() + __applyEndValue);
 102 }
 103
 104 result
 105 _VisualElementValueAnimationImpl::CopyAnimationValue(const _VisualElementValueAnimationImpl& animationImpl)
 106 {
 107         result r = _VisualElementAnimationImpl::CopyAnimationValue(animationImpl);
 108         SysTryReturnResult(NID_UI_ANIM, (r == E_SUCCESS), r, "Propagating.");
 109
 110         __pTickListener = animationImpl.__pTickListener;
 111         __start = animationImpl.__start;
 112         __end = animationImpl.__end;
 113         __applyEndValue = animationImpl.__applyEndValue;
 114
 115         if (animationImpl.__pKeyFrame != null)
 116         {
 117                 __pKeyFrame = animationImpl.__pKeyFrame->CloneN();
 118                 SysTryReturnResult(NID_UI_ANIM, (__pKeyFrame != null), E_OUT_OF_MEMORY, "Memory allocation failed.");
 119         }
 120
 121         return E_SUCCESS;
 122 }
 123
 124 void
 125 _VisualElementValueAnimationImpl::SetTickEventListener(IVisualElementAnimationTickEventListener* pListener)
 126 {
 127         __pTickListener = pListener;
 128 }
 129
 130 IVisualElementAnimationTickEventListener*
 131 _VisualElementValueAnimationImpl::GetTickEventListener(void) const
 132 {
 133         return __pTickListener;
 134 }
 135
 136 void
 137 _VisualElementValueAnimationImpl::SetStartValue(const Variant& startValue)
 138 {
 139         __start = startValue;
 140 }
 141
 142 Tizen::Ui::Variant
 143 _VisualElementValueAnimationImpl::GetStartValue(void) const
 144 {
 145         return __start;
 146 }
 147
 148 void
 149 _VisualElementValueAnimationImpl::SetEndValue(const Variant& endValue)
 150 {
 151         __end = endValue;
 152 }
 153
 154 Tizen::Ui::Variant
 155 _VisualElementValueAnimationImpl::GetEndValue(void) const
 156 {
 157         return __end;
 158 }
 159
 160 void
 161 _VisualElementValueAnimationImpl::SetEndValueApplied(bool apply)
 162 {
 163         __applyEndValue = apply;
 164 }
 165
 166 bool
 167 _VisualElementValueAnimationImpl::IsEndValueApplied(void) const
 168 {
 169         return __applyEndValue;
 170 }
 171
 172 result
 173 _VisualElementValueAnimationImpl::AddKeyFrame(float timeProgress, const Tizen::Ui::Variant& value, const IVisualElementAnimationTimingFunction* pTimingFunction)
 174 {
 175         if (__pKeyFrame == null)
 176         {
 177                 __pKeyFrame = new (std::nothrow) _VisualElementAnimationKeyFrame();
 178                 SysTryReturnResult(NID_UI_ANIM, (__pKeyFrame != null), E_OUT_OF_MEMORY, "Memory allocation failed.");
 179         }
 180         else
 181         {
 182                 _VisualElementAnimationKeyFrameInfo* pInfo = __pKeyFrame->GetKeyFrameInfoAt(0);
 183                 SysAssertf(pInfo != null, "Key frame with index 0 is null.");
 184
 185                 SysTryReturnResult(NID_UI_ANIM, (pInfo->GetValue().GetType() == value.GetType()), E_INVALID_ARG, "Invalid argument(s) is used. The value type is different from another");
 186         }
 187
 188         return __pKeyFrame->AddKeyFrame(timeProgress, value, pTimingFunction);
 189 }
 190
 191 result
 192 _VisualElementValueAnimationImpl::RemoveKeyFrame(float timeProgress)
 193 {
 194         if (__pKeyFrame == null)
 195         {
 196                 return E_OBJ_NOT_FOUND;
 197         }
 198
 199         result r = __pKeyFrame->RemoveKeyFrame(timeProgress);
 200
 201         if (__pKeyFrame->GetCount() == 0)
 202         {
 203                 delete __pKeyFrame;
 204                 __pKeyFrame = null;
 205         }
 206
 207         return r;
 208 }
 209
 210 void
 211 _VisualElementValueAnimationImpl::RemoveAllKeyFrames(void)
 212 {
 213         if (__pKeyFrame != null)
 214         {
 215                 __pKeyFrame->RemoveAllKeyFrames();
 216
 217                 delete __pKeyFrame;
 218                 __pKeyFrame = null;
 219         }
 220 }
 221
 222 _VisualElementValueAnimationImpl*
 223 _VisualElementValueAnimationImpl::GetInstance(VisualElementValueAnimation& animation)
 224 {
 225         return dynamic_cast<_VisualElementValueAnimationImpl*>(animation._pAnimationImpl);
 226 }
 227
 228 const _VisualElementValueAnimationImpl*
 229 _VisualElementValueAnimationImpl::GetInstance(const VisualElementValueAnimation& animation)
 230 {
 231         return dynamic_cast<const _VisualElementValueAnimationImpl*>(animation._pAnimationImpl);
 232 }
 233
 234 _VisualElementAnimationKeyFrame*
 235 _VisualElementValueAnimationImpl::GetKeyFrame(void) const
 236 {
 237         return __pKeyFrame;
 238 }
 239
 240 bool
 241 _VisualElementValueAnimationImpl::IsValid(void) const
 242 {
 243         return (IsValidValues() && IsValidKeyFrameType());
 244 }
 245
 246 bool
 247 _VisualElementValueAnimationImpl::IsValidKeyFrameType(void) const
 248 {
 249         if (__pKeyFrame != null)
 250         {
 251                 VariantType type;
 252
 253                 if (__start.IsEmpty() == false)
 254                 {
 255                         type = __start.GetType();
 256                 }
 257                 else
 258                 {
 259                         type = __end.GetType();
 260                 }
 261
 262                 _VisualElementAnimationKeyFrameInfo* pInfo = __pKeyFrame->GetKeyFrameInfoAt(0);
 263                 SysAssertf(pInfo != null, "Key frame with index 0 is null.");
 264
 265                 SysTryReturn(NID_UI_ANIM, (pInfo->GetValue().GetType() == type), false, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. The types of variant are different.");
 266         }
 267
 268         return true;
 269 }
 270
 271 bool
 272 _VisualElementValueAnimationImpl::IsValidValues(void) const
 273 {
 274         SysTryReturn(NID_UI_ANIM, (__start.IsEmpty() == false && __end.IsEmpty() == false), false, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. The start value or end value is invalid.");
 275         SysTryReturn(NID_UI_ANIM, (__start.GetType() == __end.GetType()), false, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. The types of variant are different.");
 276
 277         return true;
 278 }
 279
 280 void
 281 _VisualElementValueAnimationImpl::OnTickOccurred(VisualElement& target, const Tizen::Ui::Variant& currentValue)
 282 {
 283
 284 }
 285
 286
 287 }}}   // Tizen::Ui::Animations
 288