src/ui/animations/FUiAnimVisualElementAnimation.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        FUiAnimVisualElementAnimation.cpp
  20  * @brief       This file contains implementation of VisualElementAnimation class
  21  *
  22  * This file contains implementation VisualElementAnimation class.
  23  */
  24
  25 #include <pthread.h>
  26 #include <FBaseSysLog.h>
  27 #include <FBaseColHashMap.h>
  28
  29 #include <FUiAnimVisualElementAnimation.h>
  30
  31 #include "FUiAnim_TimingFunction.h"
  32 #include "FUiAnim_VisualElementAnimationImpl.h"
  33
  34 namespace Tizen { namespace Ui { namespace Animations
  35 {
  36
  37 // for TimingFunction
  38 class _Singleton
  39 {
  40 private:
  41         _Singleton(void)
  42         {
  43                 // TODO: may need lock for multi thread
  44                 pTimingFunctions = new (std::nothrow) Tizen::Base::Collection::HashMap();
  45                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctions, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  46
  47                 result r = pTimingFunctions->Construct();
  48                 if (r != E_SUCCESS)
  49                 {
  50                         delete pTimingFunctions;
  51                         pTimingFunctions = null;
  52
  53                         SetLastResult(r);
  54                         return;
  55                 }
  56
  57                 // Add timing functions to map
  58                 // Linear
  59                 LinearTimingFunction* pTimingFunctionLinear = new (std::nothrow) LinearTimingFunction();
  60                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionLinear, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  61
  62                 Tizen::Base::String* pKeyLinear = new (std::nothrow) Tizen::Base::String(L"Linear");
  63                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyLinear, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  64
  65                 pKeyLinear->ToLower();
  66                 pTimingFunctions->Add(*pKeyLinear, *pTimingFunctionLinear);
  67
  68                 // EaseIn
  69                 EaseInTimingFunction* pTimingFunctionEaseIn = new (std::nothrow) EaseInTimingFunction();
  70                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionEaseIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  71
  72                 Tizen::Base::String* pKeyEaseIn = new (std::nothrow) Tizen::Base::String(L"EaseIn");
  73                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyEaseIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  74
  75                 pKeyEaseIn->ToLower();
  76                 pTimingFunctions->Add(*pKeyEaseIn, *pTimingFunctionEaseIn);
  77
  78                 // EaseOut
  79                 EaseOutTimingFunction* pTimingFunctionEaseOut = new (std::nothrow) EaseOutTimingFunction();
  80                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionEaseOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  81
  82                 Tizen::Base::String* pKeyEaseOut = new (std::nothrow) Tizen::Base::String(L"EaseOut");
  83                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyEaseOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  84
  85                 pKeyEaseOut->ToLower();
  86                 pTimingFunctions->Add(*pKeyEaseOut, *pTimingFunctionEaseOut);
  87
  88                 // EaseInOut
  89                 EaseInOutTimingFunction* pTimingFunctionEaseInOut = new (std::nothrow) EaseInOutTimingFunction();
  90                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionEaseInOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  91
  92                 Tizen::Base::String* pKeyEaseInOut = new (std::nothrow) Tizen::Base::String(L"EaseInOut");
  93                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyEaseInOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  94
  95                 pKeyEaseInOut->ToLower();
  96                 pTimingFunctions->Add(*pKeyEaseInOut, *pTimingFunctionEaseInOut);
  97
  98                 // EaseOutIn
  99                 EaseOutInTimingFunction* pTimingFunctionEaseOutIn = new (std::nothrow) EaseOutInTimingFunction();
 100                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionEaseOutIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 101
 102                 Tizen::Base::String* pKeyEaseOutIn = new (std::nothrow) Tizen::Base::String(L"EaseOutIn");
 103                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyEaseOutIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 104
 105                 pKeyEaseOutIn->ToLower();
 106                 pTimingFunctions->Add(*pKeyEaseOutIn, *pTimingFunctionEaseOutIn);
 107
 108                 // Discrete
 109                 DiscreteTimingFunction* pTimingFunctionDiscrete = new (std::nothrow) DiscreteTimingFunction();
 110                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionDiscrete, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 111
 112                 Tizen::Base::String* pKeyDiscrete = new (std::nothrow) Tizen::Base::String(L"Discrete");
 113                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyDiscrete, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 114
 115                 pKeyDiscrete->ToLower();
 116                 pTimingFunctions->Add(*pKeyDiscrete, *pTimingFunctionDiscrete);
 117
 118                 // Bezier
 119                 BezierTimingFunction* pTimingFunctionBezier = new (std::nothrow) BezierTimingFunction();
 120                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionBezier, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 121
 122                 Tizen::Base::String* pKeyBezier = new (std::nothrow) Tizen::Base::String(L"Bezier");
 123                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyBezier, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 124
 125                 pKeyBezier->ToLower();
 126                 pTimingFunctions->Add(*pKeyBezier, *pTimingFunctionBezier);
 127
 128                 // ExpIn
 129                 ExpInTimingFunction* pTimingFunctionExpIn = new (std::nothrow) ExpInTimingFunction();
 130                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionExpIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 131
 132                 Tizen::Base::String* pKeyExpIn = new (std::nothrow) Tizen::Base::String(L"ExpIn");
 133                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyExpIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 134
 135                 pKeyExpIn->ToLower();
 136                 pTimingFunctions->Add(*pKeyExpIn, *pTimingFunctionExpIn);
 137
 138                 // ExpOut
 139                 ExpOutTimingFunction* pTimingFunctionExpOut = new (std::nothrow) ExpOutTimingFunction();
 140                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionExpOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 141
 142                 Tizen::Base::String* pKeyExpOut = new (std::nothrow) Tizen::Base::String(L"ExpOut");
 143                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyExpOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 144
 145                 pKeyExpOut->ToLower();
 146                 pTimingFunctions->Add(*pKeyExpOut, *pTimingFunctionExpOut);
 147
 148                 // EaseElasticIn
 149                 EaseElasticInTimingFunction* pTimingFunctionEaseElasticIn = new (std::nothrow) EaseElasticInTimingFunction();
 150                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionEaseElasticIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 151
 152                 Tizen::Base::String* pKeyEaseElasticIn = new (std::nothrow) Tizen::Base::String(L"EaseElasticIn");
 153                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyEaseElasticIn, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 154
 155                 pKeyEaseElasticIn->ToLower();
 156                 pTimingFunctions->Add(*pKeyEaseElasticIn, *pTimingFunctionEaseElasticIn);
 157
 158                 // EaseElasticOut
 159                 EaseElasticOutTimingFunction* pTimingFunctionEaseElasticOut = new (std::nothrow) EaseElasticOutTimingFunction();
 160                 SysTryReturnVoidResult(NID_UI_ANIM, pTimingFunctionEaseElasticOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 161
 162                 Tizen::Base::String* pKeyEaseElasticOut = new (std::nothrow) Tizen::Base::String(L"EaseElasticOut");
 163                 SysTryReturnVoidResult(NID_UI_ANIM, pKeyEaseElasticOut, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 164
 165                 pKeyEaseElasticOut->ToLower();
 166                 pTimingFunctions->Add(*pKeyEaseElasticOut, *pTimingFunctionEaseElasticOut);
 167         }
 168
 169         ~_Singleton(void)
 170         {
 171                 if (pTimingFunctions)
 172                 {
 173                         pTimingFunctions->RemoveAll(true);
 174                 }
 175
 176                 delete pTimingFunctions;
 177                 pTimingFunctions = null;
 178         }
 179
 180         static void
 181         InitSingleton(void)
 182         {
 183             static _Singleton inst;
 184             __pInstance = &inst;
 185         }
 186
 187 public:
 188         static _Singleton*
 189         GetInstance(void)
 190         {
 191             static pthread_once_t once_block = PTHREAD_ONCE_INIT;
 192             if (!__pInstance)
 193             {
 194                 pthread_once(&once_block, InitSingleton);
 195             }
 196
 197             return __pInstance;
 198         }
 199
 200
 201 public:
 202         Tizen::Base::Collection::HashMap* pTimingFunctions;
 203
 204 private:
 205         _Singleton(const _Singleton& rhs);
 206         _Singleton& operator =(const _Singleton& rhs);
 207         static _Singleton* __pInstance;
 208
 209 };
 210
 211 _Singleton* _Singleton::__pInstance = null;
 212
 213 VisualElementAnimation::VisualElementAnimation(void)
 214 {
 215         ClearLastResult();
 216
 217         _pAnimationImpl = new (std::nothrow) _VisualElementAnimationImpl();
 218         if (_pAnimationImpl == null)
 219         {
 220                 SetLastResult(E_OUT_OF_MEMORY);
 221         }
 222 }
 223
 224 VisualElementAnimation::~VisualElementAnimation(void)
 225 {
 226         if (_pAnimationImpl)
 227         {
 228                 delete _pAnimationImpl;
 229                 _pAnimationImpl = null;
 230         }
 231 }
 232
 233 VisualElementAnimation::VisualElementAnimation(_VisualElementAnimationImpl* pAnimationImpl)
 234         : _pAnimationImpl(pAnimationImpl)
 235 {
 236         ClearLastResult();
 237 }
 238
 239 VisualElementAnimation::VisualElementAnimation(const VisualElementAnimation& animation)
 240         : _pAnimationImpl(null)
 241 {
 242         ClearLastResult();
 243
 244         _pAnimationImpl = new (std::nothrow) _VisualElementAnimationImpl(*(animation._pAnimationImpl));
 245         SysTryReturnVoidResult(NID_UI_ANIM, (_pAnimationImpl != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 246 }
 247
 248 VisualElementAnimation&
 249 VisualElementAnimation::operator =(const VisualElementAnimation& rhs)
 250 {
 251         if (this != (&rhs))
 252         {
 253                 result r = _pAnimationImpl->CopyAnimationValue(*(rhs._pAnimationImpl));
 254                 SysTryReturn(NID_UI_ANIM, (r == E_SUCCESS), *this, r, "[%s] Failed to copy the animation value.", GetErrorMessage(r));
 255         }
 256
 257         return *this;
 258 }
 259
 260 bool
 261 VisualElementAnimation::operator ==(const VisualElementAnimation& rhs) const
 262 {
 263         if (this == &rhs)
 264         {
 265                 return true;
 266         }
 267
 268         return (_pAnimationImpl->Equals(*(rhs._pAnimationImpl)));
 269 }
 270
 271 bool
 272 VisualElementAnimation::operator !=(const VisualElementAnimation& rhs) const
 273 {
 274         return (!operator == (rhs));
 275 }
 276
 277 bool
 278 VisualElementAnimation::Equals(const Tizen::Base::Object& obj) const
 279 {
 280         const VisualElementAnimation* pAnimation = dynamic_cast< const VisualElementAnimation* >(&obj);
 281
 282         if (pAnimation == null)
 283         {
 284                 return false;
 285         }
 286
 287         return (*this == *pAnimation);
 288 }
 289
 290 int
 291 VisualElementAnimation::GetHashCode(void) const
 292 {
 293         return _pAnimationImpl->GetHashCode();
 294 }
 295
 296 VisualElementAnimation*
 297 VisualElementAnimation::CloneN(void) const
 298 {
 299         VisualElementAnimation* pCloned = new (std::nothrow) VisualElementAnimation(*this);
 300         SysTryReturn(NID_UI_ANIM, (pCloned != null), null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 301
 302         return pCloned;
 303 }
 304
 305 void
 306 VisualElementAnimation::SetVisualElementAnimationStatusEventListener(IVisualElementAnimationStatusEventListener* pListener)
 307 {
 308         _pAnimationImpl->SetStatusEventListener(pListener);
 309 }
 310
 311 IVisualElementAnimationStatusEventListener*
 312 VisualElementAnimation::GetVisualElementAnimationStatusEventListener(void) const
 313 {
 314         return _pAnimationImpl->GetStatusEventListener();
 315 }
 316
 317 void
 318 VisualElementAnimation::SetTimingFunction(const IVisualElementAnimationTimingFunction* pTimingFunction)
 319 {
 320         _pAnimationImpl->SetTimingFunction(pTimingFunction);
 321 }
 322
 323 const IVisualElementAnimationTimingFunction*
 324 VisualElementAnimation::GetTimingFunction(void) const
 325 {
 326         return _pAnimationImpl->GetTimingFunction();
 327 }
 328
 329 void
 330 VisualElementAnimation::SetValueInterpolator(const IVisualElementAnimationValueInterpolator* pInterpolator)
 331 {
 332         _pAnimationImpl->SetValueInterpolator(pInterpolator);
 333 }
 334
 335 const IVisualElementAnimationValueInterpolator*
 336 VisualElementAnimation::GetValueInterpolator(void) const
 337 {
 338         return _pAnimationImpl->GetValueInterpolator();
 339 }
 340
 341 result
 342 VisualElementAnimation::SetDuration(long milliseconds)
 343 {
 344         SysTryReturnResult(NID_UI_ANIM, (milliseconds >= 0 && milliseconds >= _pAnimationImpl->GetOffset()),
 345                                                 E_INVALID_ARG, "Invalid argument(s) is used. milliseconds = %ld", milliseconds);
 346
 347         _pAnimationImpl->SetDuration(milliseconds);
 348
 349         return E_SUCCESS;
 350 }
 351
 352 long
 353 VisualElementAnimation::GetDuration(void) const
 354 {
 355         return _pAnimationImpl->GetDuration();
 356 }
 357
 358 result
 359 VisualElementAnimation::SetOffset(long milliseconds)
 360 {
 361         SysTryReturnResult(NID_UI_ANIM, (milliseconds >= 0 && milliseconds <= _pAnimationImpl->GetDuration()),
 362                                                 E_INVALID_ARG, "Invalid argument(s) is used. milliseconds = %ld", milliseconds);
 363
 364         _pAnimationImpl->SetOffset(milliseconds);
 365
 366         return E_SUCCESS;
 367 }
 368
 369 long
 370 VisualElementAnimation::GetOffset(void) const
 371 {
 372         return _pAnimationImpl->GetOffset();
 373 }
 374
 375 result
 376 VisualElementAnimation::SetDelay(long milliseconds)
 377 {
 378         SysTryReturnResult(NID_UI_ANIM, (milliseconds >= 0), E_INVALID_ARG, "Invalid argument(s) is used. milliseconds = %ld", milliseconds);
 379
 380         _pAnimationImpl->SetDelay(milliseconds);
 381
 382         return E_SUCCESS;
 383 }
 384
 385 long
 386 VisualElementAnimation::GetDelay(void) const
 387 {
 388         return _pAnimationImpl->GetDelay();
 389 }
 390
 391 result
 392 VisualElementAnimation::SetRepeatCount(long count)
 393 {
 394         SysTryReturnResult(NID_UI_ANIM, (count >= 0), E_INVALID_ARG, "Invalid argument(s) is used. count = %ld", count);
 395
 396         _pAnimationImpl->SetRepeatCount(count);
 397
 398         return E_SUCCESS;
 399 }
 400
 401 long
 402 VisualElementAnimation::GetRepeatCount(void) const
 403 {
 404         return _pAnimationImpl->GetRepeatCount();
 405 }
 406
 407 void
 408 VisualElementAnimation::SetAutoReverseEnabled(bool autoReverse)
 409 {
 410         _pAnimationImpl->SetAutoReverseEnabled(autoReverse);
 411 }
 412
 413 bool
 414 VisualElementAnimation::IsAutoReverseEnabled(void) const
 415 {
 416         return _pAnimationImpl->IsAutoReverseEnabled();
 417 }
 418
 419 result
 420 VisualElementAnimation::SetScaleRatio(float scaleRatio)
 421 {
 422         SysTryReturnResult(NID_UI_ANIM, (scaleRatio > 0.f), E_INVALID_ARG, "Invalid argument(s) is used. scaleRatio = %f", scaleRatio);
 423
 424         _pAnimationImpl->SetScaleRatio(scaleRatio);
 425
 426         return E_SUCCESS;
 427 }
 428
 429 float
 430 VisualElementAnimation::GetScaleRatio(void) const
 431 {
 432         return _pAnimationImpl->GetScaleRatio();
 433 }
 434
 435 void
 436 VisualElementAnimation::SetUserData(void* pUserData)
 437 {
 438         _pAnimationImpl->SetUserData(pUserData);
 439 }
 440
 441 void*
 442 VisualElementAnimation::GetUserData(void) const
 443 {
 444         return _pAnimationImpl->GetUserData();
 445 }
 446
 447 const IVisualElementAnimationTimingFunction*
 448 VisualElementAnimation::GetTimingFunctionByName(const Tizen::Base::String& name)
 449 {
 450         _Singleton* pInstance = _Singleton::GetInstance();
 451
 452         SysTryReturn(NID_UI_ANIM, pInstance, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 453         SysTryReturn(NID_UI_ANIM, pInstance->pTimingFunctions, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 454
 455         const_cast< Tizen::Base::String& >(name).ToLower();
 456
 457         IVisualElementAnimationTimingFunction* pTimingFunction = dynamic_cast< IVisualElementAnimationTimingFunction* >(pInstance->pTimingFunctions->GetValue(name));
 458
 459         SysTryReturn(NID_UI_ANIM, pTimingFunction, null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. name = %ls.", name.GetPointer());
 460
 461         return pTimingFunction;
 462 }
 463
 464 }}}   // Tizen::Ui::Animations
 465