src/ui/animations/FUiAnimAnimationBase.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        FUiAnimAnimationBase.cpp
  20  * @brief       This file contains implementation of AnimationBase class
  21  *
  22  * This file contains implementation of AnimationBase class.
  23  */
  24
  25
  26 #include <FBaseSysLog.h>
  27 #include <FBaseColIMapEnumerator.h>
  28 #include <FBaseColIListT.h>
  29 #include <FBaseColArrayList.h>
  30 #include <FBaseColHashMapT.h>
  31 #include <FBaseFloatComparer.h>
  32 #include <FBaseComparerT.h>
  33
  34 #include <FUiAnimAnimationBase.h>
  35
  36 #include "FUiAnim_AnimationBaseImpl.h"
  37
  38
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Base::Collection;
  41
  42
  43 namespace Tizen { namespace Ui { namespace Animations
  44 {
  45
  46 AnimationBase::AnimationBase(void)
  47         : _pAnimationBaseImpl(null)
  48 {
  49 }
  50
  51 AnimationBase::~AnimationBase(void)
  52 {
  53         if (_pAnimationBaseImpl != null)
  54         {
  55                 delete _pAnimationBaseImpl;
  56                 _pAnimationBaseImpl = null;
  57         }
  58 }
  59
  60 AnimationBase::AnimationBase(const AnimationBase& animationBase)
  61 {
  62         ClearLastResult();
  63
  64         result r = E_SUCCESS;
  65
  66         _pAnimationBaseImpl = new (std::nothrow) _AnimationBaseImpl(this);
  67         SysTryReturnVoidResult(NID_UI_ANIM, (_pAnimationBaseImpl != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  68
  69         r = _pAnimationBaseImpl->Construct();
  70         if (r != E_SUCCESS)
  71         {
  72                 SysLogException(NID_UI_ANIM, r, "[%s] Failed to construct _AnimationBaseImpl instance.", GetErrorMessage(r));
  73
  74                 delete _pAnimationBaseImpl;
  75                 _pAnimationBaseImpl = null;
  76
  77                 return;
  78         }
  79
  80         SetInterpolatorType(animationBase.GetInterpolatorType());
  81         SetBezierControlPoints(animationBase._pAnimationBaseImpl->controlPointTime1,
  82                                                         animationBase._pAnimationBaseImpl->controlPointValue1,
  83                                                         animationBase._pAnimationBaseImpl->controlPointTime2,
  84                                                         animationBase._pAnimationBaseImpl->controlPointValue2);
  85         SetDuration(animationBase.GetDuration());
  86         SetDelay(animationBase.GetDelay());
  87         SetOffset(animationBase.GetOffset());
  88         SetRepeatCount(animationBase.GetRepeatCount());
  89         SetAutoReverseEnabled(animationBase.IsAutoReverseEnabled());
  90         SetScaleRatio(animationBase.GetScaleRatio());
  91         SetHoldEndEnabled(animationBase.IsHoldEndEnabled());
  92         SetName(animationBase.GetName());
  93 }
  94
  95 AnimationBase::AnimationBase(long duration, AnimationInterpolatorType interpolator)
  96         : _pAnimationBaseImpl(null)
  97 {
  98         ClearLastResult();
  99
 100         SysTryReturnVoidResult(NID_UI_ANIM, (duration >= 0), E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. duration = %ld", duration);
 101         SysTryReturnVoidResult(NID_UI_ANIM, (interpolator >= ANIMATION_INTERPOLATOR_LINEAR && interpolator <= ANIMATION_INTERPOLATOR_BEZIER),
 102                                                         E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. interpolator is invalid.");
 103
 104         result r = E_SUCCESS;
 105
 106         _pAnimationBaseImpl = new (std::nothrow) _AnimationBaseImpl(this);
 107         SysTryReturnVoidResult(NID_UI_ANIM, (_pAnimationBaseImpl != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 108
 109         r = _pAnimationBaseImpl->Construct();
 110         if (r != E_SUCCESS)
 111         {
 112                 SysLogException(NID_UI_ANIM, r, "[%s] Propagating.", GetErrorMessage(r));
 113
 114                 delete _pAnimationBaseImpl;
 115                 _pAnimationBaseImpl = null;
 116
 117                 return;
 118         }
 119
 120         _pAnimationBaseImpl->duration = duration;
 121         _pAnimationBaseImpl->interpolator = interpolator;
 122 }
 123
 124 AnimationBase&
 125 AnimationBase::operator =(const AnimationBase& rhs)
 126 {
 127         if ((&rhs) != this)
 128         {
 129                 SetInterpolatorType(rhs.GetInterpolatorType());
 130                 SetBezierControlPoints(rhs._pAnimationBaseImpl->controlPointTime1, rhs._pAnimationBaseImpl->controlPointValue1,
 131                                                                 rhs._pAnimationBaseImpl->controlPointTime2, rhs._pAnimationBaseImpl->controlPointValue2);
 132                 SetDuration(rhs.GetDuration());
 133                 SetDelay(rhs.GetDelay());
 134                 SetOffset(rhs.GetOffset());
 135                 SetRepeatCount(rhs.GetRepeatCount());
 136                 SetAutoReverseEnabled(rhs.IsAutoReverseEnabled());
 137                 SetScaleRatio(rhs.GetScaleRatio());
 138                 SetHoldEndEnabled(rhs.IsHoldEndEnabled());
 139                 SetName(rhs.GetName());
 140         }
 141
 142         return *this;
 143 }
 144
 145 void
 146 AnimationBase::SetInterpolatorType(AnimationInterpolatorType interpolator)
 147 {
 148         _pAnimationBaseImpl->interpolator = interpolator;
 149 }
 150
 151 AnimationInterpolatorType
 152 AnimationBase::GetInterpolatorType(void) const
 153 {
 154         return _pAnimationBaseImpl->interpolator;
 155 }
 156
 157 result
 158 AnimationBase::SetBezierControlPoints(float controlPointTime1, float controlPointValue1, float controlPointTime2, float controlPointValue2)
 159 {
 160         SysTryReturnResult(NID_UI_ANIM, (controlPointTime1 >= 0.0f && controlPointTime1 <= 1.0f), E_INVALID_ARG, "Invalid argument(s) is used. controlPointTime1 = %f", controlPointTime1);
 161         SysTryReturnResult(NID_UI_ANIM, (controlPointValue1 >= 0.0f && controlPointValue1 <= 1.0f), E_INVALID_ARG, "Invalid argument(s) is used. controlPointValue1 = %f", controlPointValue1);
 162         SysTryReturnResult(NID_UI_ANIM, (controlPointTime2 >= 0.0f && controlPointTime2 <= 1.0f), E_INVALID_ARG, "Invalid argument(s) is used. controlPointTime2 = %f", controlPointTime2);
 163         SysTryReturnResult(NID_UI_ANIM, (controlPointValue2 >= 0.0f && controlPointValue2 <= 1.0f), E_INVALID_ARG, "Invalid argument(s) is used. controlPointValue2 = %f", controlPointValue2);
 164
 165         if (_pAnimationBaseImpl->interpolator != ANIMATION_INTERPOLATOR_BEZIER)
 166         {
 167                 return E_INVALID_OPERATION;
 168         }
 169
 170         _pAnimationBaseImpl->controlPointTime1 = controlPointTime1;
 171         _pAnimationBaseImpl->controlPointValue1 = controlPointValue1;
 172         _pAnimationBaseImpl->controlPointTime2 = controlPointTime2;
 173         _pAnimationBaseImpl->controlPointValue2 = controlPointValue2;
 174
 175         return E_SUCCESS;
 176 }
 177
 178 result
 179 AnimationBase::GetBezierControlPoints(float& controlPointTime1, float& controlPointValue1, float& controlPointTime2, float& controlPointValue2) const
 180 {
 181         if (_pAnimationBaseImpl->interpolator != ANIMATION_INTERPOLATOR_BEZIER)
 182         {
 183                 return E_INVALID_OPERATION;
 184         }
 185
 186         controlPointTime1 = _pAnimationBaseImpl->controlPointTime1;
 187         controlPointValue1 = _pAnimationBaseImpl->controlPointValue1;
 188         controlPointTime2 = _pAnimationBaseImpl->controlPointTime2;
 189         controlPointValue2 = _pAnimationBaseImpl->controlPointValue2;
 190
 191         return E_SUCCESS;
 192 }
 193
 194 int
 195 AnimationBase::GetKeyFrameCount(void) const
 196 {
 197         return _pAnimationBaseImpl->keyFrameList.GetCount();
 198 }
 199
 200 void
 201 AnimationBase::SetName(const String& name)
 202 {
 203         _pAnimationBaseImpl->animName = name;
 204
 205 }
 206
 207 String
 208 AnimationBase::GetName(void) const
 209 {
 210         return _pAnimationBaseImpl->animName;
 211 }
 212
 213 result
 214 AnimationBase::SetDuration(long milliSeconds)
 215 {
 216         SysTryReturnResult(NID_UI_ANIM, (milliSeconds >= 0), E_INVALID_ARG, "Invalid argument(s) is used. milliSeconds = %ld", milliSeconds);
 217
 218         _pAnimationBaseImpl->duration = milliSeconds;
 219
 220         return E_SUCCESS;
 221 }
 222
 223 result
 224 AnimationBase::SetOffset(long milliSeconds)
 225 {
 226         SysTryReturnResult(NID_UI_ANIM, (milliSeconds >= 0 && milliSeconds <= _pAnimationBaseImpl->duration), E_INVALID_ARG,
 227                                          "Invalid argument(s) is used. milliSeconds = %ld", milliSeconds);
 228
 229         _pAnimationBaseImpl->offset = milliSeconds;
 230
 231         return E_SUCCESS;
 232 }
 233
 234 result
 235 AnimationBase::SetDelay(long milliSeconds)
 236 {
 237         SysTryReturnResult(NID_UI_ANIM, (milliSeconds >= 0), E_INVALID_ARG, "Invalid argument(s) is used. milliSeconds = %ld", milliSeconds);
 238
 239         _pAnimationBaseImpl->delay = milliSeconds;
 240
 241         return E_SUCCESS;
 242 }
 243
 244 result
 245 AnimationBase::SetRepeatCount(long count)
 246 {
 247         SysTryReturnResult(NID_UI_ANIM, (count >= 1), E_INVALID_ARG, "Invalid argument(s) is used. count = %ld", count);
 248
 249         _pAnimationBaseImpl->repeatCount = count;
 250
 251         return E_SUCCESS;
 252 }
 253
 254 void
 255 AnimationBase::SetAutoReverseEnabled(bool autoReverse)
 256 {
 257         _pAnimationBaseImpl->autoReverse = autoReverse;
 258 }
 259
 260 result
 261 AnimationBase::SetScaleRatio(float scaleRatio)
 262 {
 263         SysTryReturnResult(NID_UI_ANIM, (scaleRatio >= 0), E_INVALID_ARG, "Invalid argument(s) is used. scaleRatio = %f", scaleRatio);
 264
 265         _pAnimationBaseImpl->scaleRatio = scaleRatio;
 266         return E_SUCCESS;
 267 }
 268
 269 void
 270 AnimationBase::SetHoldEndEnabled(bool holdEnd)
 271 {
 272         _pAnimationBaseImpl->holdEnd = holdEnd;
 273 }
 274
 275 long
 276 AnimationBase::GetDuration(void) const
 277 {
 278         return _pAnimationBaseImpl->duration;
 279 }
 280
 281 long
 282 AnimationBase::GetOffset(void) const
 283 {
 284         return _pAnimationBaseImpl->offset;
 285 }
 286
 287 long
 288 AnimationBase::GetDelay(void) const
 289 {
 290         return _pAnimationBaseImpl->delay;
 291 }
 292
 293 long
 294 AnimationBase::GetRepeatCount(void) const
 295 {
 296         return _pAnimationBaseImpl->repeatCount;
 297 }
 298
 299 bool
 300 AnimationBase::IsAutoReverseEnabled(void) const
 301 {
 302         return _pAnimationBaseImpl->autoReverse;
 303 }
 304
 305 float
 306 AnimationBase::GetScaleRatio(void) const
 307 {
 308         return _pAnimationBaseImpl->scaleRatio;
 309 }
 310
 311 bool
 312 AnimationBase::IsHoldEndEnabled(void) const
 313 {
 314         return _pAnimationBaseImpl->holdEnd;
 315 }
 316
 317 void
 318 AnimationBase::AnimationBase_Reserved1(void)
 319 {
 320 }
 321
 322 void
 323 AnimationBase::AnimationBase_Reserved2(void)
 324 {
 325 }
 326
 327 void
 328 AnimationBase::AnimationBase_Reserved3(void)
 329 {
 330 }
 331
 332
 333 }}}             // Tizen::Ui::Animations
 334