src/ui/animations/FUiAnimVisualElement.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        FUiAnimVisualElement.cpp
  20  * @brief       This file contains implementation of VisualElement class
  21  *
  22  * This file contains implementation VisualElement class.
  23  */
  24
  25 #include <FBaseString.h>
  26 #include <FGrpCanvas.h>
  27 #include <FUiAnimVisualElement.h>
  28 #include <FUiAnimVisualElementSurface.h>
  29 #include <FUiAnimVisualElementAnimation.h>
  30
  31 #include "FUiAnim_VisualElementAnimationImpl.h"
  32 #include "FUiAnim_VisualElementImpl.h"
  33
  34 #include "FUiAnim_Debug.h"
  35
  36 #define CHECK_NOT_CONSTRUCTED \
  37         SysAssertf(_pVisualElementImpl->__pSharedData == null, "Already constructed! Calling Construct() twice or more on a same instance is not allowed for this class.");
  38
  39 #define CHECK_CONSTRUCTED \
  40         SysAssertf(_pVisualElementImpl->__pSharedData != null, "Not yet constructed! Construct() should be called before use.");
  41
  42 #define CHECK_PARAMETER_CONSTRUCTED(element) \
  43         SysAssertf((element)._pVisualElementImpl && (element)._pVisualElementImpl->__pSharedData, "Not yet constructed! Construct() should be called before use.");
  44
  45 namespace Tizen { namespace Ui { namespace Animations
  46 {
  47
  48 using namespace Tizen;
  49 using namespace Tizen::Base;
  50 using namespace Tizen::Base::Collection;
  51 using namespace Tizen::Graphics;
  52
  53 VisualElement::VisualElement(void)
  54         : _pVisualElementImpl(null)
  55 {
  56         _pVisualElementImpl = new (std::nothrow) _VisualElementImpl(*this);
  57 }
  58
  59 VisualElement::VisualElement(const VisualElement& rhs)
  60         : _pVisualElementImpl(null)
  61 {
  62         CHECK_PARAMETER_CONSTRUCTED(rhs);
  63
  64         _pVisualElementImpl = new (std::nothrow) _VisualElementImpl(*this, *rhs._pVisualElementImpl);
  65 }
  66
  67 VisualElement*
  68 VisualElement::CloneN(void) const
  69 {
  70         CHECK_CONSTRUCTED;
  71
  72         VisualElement* pCloned = new (std::nothrow) VisualElement(*this);
  73         SysTryReturn(NID_UI_ANIM, pCloned, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  74
  75         return pCloned;
  76 }
  77
  78 VisualElement::~VisualElement(void)
  79 {
  80         if (_pVisualElementImpl)
  81         {
  82                 SysLogException(NID_UI_ANIM, E_INVALID_STATE, "[E_INVALID_STATE] should be called Destroy() for deallocating the VisualElement.");
  83                 _pVisualElementImpl->Destroy();
  84                 _pVisualElementImpl = null;
  85         }
  86 }
  87
  88 result
  89 VisualElement::Construct(void)
  90 {
  91         SysTryReturnResult(NID_UI_ANIM, _pVisualElementImpl, E_OUT_OF_MEMORY, "Memory allocation failed.");
  92
  93         SysAssertf(_pVisualElementImpl->__pSharedData == null, "Already constructed! Calling Construct() twice or more on a same instance is not allowed for this class.");
  94
  95         result r = E_SUCCESS;
  96         VisualElement* pClone = null;
  97
  98         r = _pVisualElementImpl->Construct();
  99         SysTryCatch(NID_UI_ANIM, r == E_SUCCESS, , r, "[%s] Failed to construct VisualElement instance.", GetErrorMessage(r));
 100
 101         pClone = CloneN();
 102         SysTryReturnResult(NID_UI_ANIM, pClone, E_INVALID_STATE, "Failed to create the presentation.");
 103         SysTryCatch(NID_UI_ANIM, pClone->_pVisualElementImpl, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Presentation is invalid.");
 104
 105         pClone->_pVisualElementImpl->__pSharedData = _pVisualElementImpl->__pSharedData;
 106         pClone->_pVisualElementImpl->__pSharedData->AddRef();
 107         _pVisualElementImpl->__pSharedData->invalidatedNativeProps = _VisualElementImpl::HIERARCHY_PROPERTY_MASK;
 108
 109         pClone->_pVisualElementImpl->__pModel = _pVisualElementImpl;
 110         pClone->_pVisualElementImpl->__pPresentation = pClone->_pVisualElementImpl;
 111
 112         _pVisualElementImpl->__pModel = _pVisualElementImpl;
 113         _pVisualElementImpl->__pPresentation = pClone->_pVisualElementImpl;
 114
 115
 116         // WARNING:
 117         //      Exceptional case for constructed-callback:
 118         //              This callback is invoked inside public-class, not inside impl-class because 'Construct' method will not be called for cloned(Presentation) VE
 119
 120         // This is model object, not presentation object.
 121         _pVisualElementImpl->InvokeOnConstructed();
 122         //pClone->_pVisualElementImpl->InvokeOnConstructed();
 123
 124         return r;
 125
 126 CATCH:
 127         delete pClone;
 128
 129         return r;
 130 }
 131
 132 void
 133 VisualElement::Destroy(void)
 134 {
 135         if (likely(_pVisualElementImpl))
 136         {
 137                 if (likely(!_pVisualElementImpl->__isDestroying))
 138                 {
 139                         _pVisualElementImpl->Destroy();
 140                         _pVisualElementImpl = null;
 141
 142                         delete this;
 143                 }
 144         }
 145         else
 146         {
 147                 delete this;
 148         }
 149 }
 150
 151 Variant
 152 VisualElement::GetProperty(const Tizen::Base::String& property) const
 153 {
 154         CHECK_CONSTRUCTED;
 155
 156         return _pVisualElementImpl->InvokeOnGetPropertyRequested(property);
 157 }
 158
 159 Variant
 160 VisualElement::OnGetPropertyRequested(const Tizen::Base::String& property) const
 161 {
 162         CHECK_CONSTRUCTED;
 163
 164         return _pVisualElementImpl->GetProperty(property);
 165 }
 166
 167 result
 168 VisualElement::SetProperty(const Tizen::Base::String& property, const Variant& value)
 169 {
 170         CHECK_CONSTRUCTED;
 171
 172         return _pVisualElementImpl->InvokeOnSetPropertyRequested(property, value);
 173 }
 174
 175 result
 176 VisualElement::OnSetPropertyRequested(const Tizen::Base::String& property, const Variant& value)
 177 {
 178         CHECK_CONSTRUCTED;
 179         result r = E_SUCCESS;
 180
 181         r =_pVisualElementImpl->SetProperty(property, value);
 182         if(r == E_KEY_NOT_FOUND)
 183         {
 184                 r = _pVisualElementImpl->UpdatePresentationWhenCustomPropertyChanged(property, value);
 185         }
 186         return r;
 187 }
 188
 189 result
 190 VisualElement::SetZOrderGroup(int zOrderGroup)
 191 {
 192         CHECK_CONSTRUCTED;
 193
 194         SysTryReturnResult(NID_UI_ANIM, zOrderGroup >= Z_ORDER_GROUP_LOWEST, E_OUT_OF_RANGE, "zOrderGroup is less than Z_ORDER_GROUP_LOWEST");
 195         SysTryReturnResult(NID_UI_ANIM, zOrderGroup <= Z_ORDER_GROUP_HIGHEST, E_OUT_OF_RANGE, "zOrderGroup is greater than Z_ORDER_GROUP_HIGHEST");
 196
 197         return _pVisualElementImpl->SetZOrderGroup(zOrderGroup);
 198 }
 199
 200 int
 201 VisualElement::GetZOrderGroup(void) const
 202 {
 203         CHECK_CONSTRUCTED;
 204
 205         return _pVisualElementImpl->GetZOrderGroup();
 206 }
 207
 208 bool
 209 VisualElement::IsRedrawOnResizeEnabled(void) const
 210 {
 211         CHECK_CONSTRUCTED;
 212
 213         return _pVisualElementImpl->GetRedrawOnResizeEnabled();
 214 }
 215
 216 void
 217 VisualElement::SetRedrawOnResizeEnabled(bool enabled)
 218 {
 219         CHECK_CONSTRUCTED;
 220
 221         _pVisualElementImpl->SetRedrawOnResizeEnabled(enabled);
 222 }
 223
 224 FloatRectangle
 225 VisualElement::GetBounds(void) const
 226 {
 227         CHECK_CONSTRUCTED;
 228
 229         return _pVisualElementImpl->GetBounds();
 230 }
 231
 232 result
 233 VisualElement::SetBounds(const FloatRectangle& bounds)
 234 {
 235         CHECK_CONSTRUCTED;
 236
 237         return _pVisualElementImpl->SetBounds(bounds);
 238 }
 239
 240 float
 241 VisualElement::GetZPosition(void) const
 242 {
 243         CHECK_CONSTRUCTED;
 244
 245         return _pVisualElementImpl->GetZPosition();
 246 }
 247
 248 void
 249 VisualElement::SetZPosition(float zPosition)
 250 {
 251         CHECK_CONSTRUCTED;
 252
 253         _pVisualElementImpl->SetZPosition(zPosition);
 254 }
 255
 256 bool
 257 VisualElement::IsVisible(void) const
 258 {
 259         CHECK_CONSTRUCTED;
 260
 261         return _pVisualElementImpl->IsVisible();
 262 }
 263
 264 bool
 265 VisualElement::GetShowState(void) const
 266 {
 267         CHECK_CONSTRUCTED;
 268
 269         return _pVisualElementImpl->GetShowState();
 270 }
 271
 272 void
 273 VisualElement::SetShowState(bool show)
 274 {
 275         CHECK_CONSTRUCTED;
 276
 277         _pVisualElementImpl->SetShowState(show);
 278 }
 279
 280 float
 281 VisualElement::GetOpacity(void) const
 282 {
 283         CHECK_CONSTRUCTED;
 284
 285         return _pVisualElementImpl->GetOpacity();
 286 }
 287
 288 void
 289 VisualElement::SetOpacity(float opacity)
 290 {
 291         CHECK_CONSTRUCTED;
 292
 293         _pVisualElementImpl->SetOpacity(opacity);
 294 }
 295
 296 Tizen::Graphics::FloatMatrix4
 297 VisualElement::GetTransformMatrix(void) const
 298 {
 299         CHECK_CONSTRUCTED;
 300
 301         return _pVisualElementImpl->GetTransformMatrix();
 302 }
 303
 304 result
 305 VisualElement::SetTransformMatrix(const Tizen::Graphics::FloatMatrix4& transform)
 306 {
 307         CHECK_CONSTRUCTED;
 308
 309         return _pVisualElementImpl->SetTransformMatrix(transform);
 310 }
 311
 312 Tizen::Graphics::FloatMatrix4
 313 VisualElement::GetChildrenTransformMatrix(void) const
 314 {
 315         CHECK_CONSTRUCTED;
 316
 317         return _pVisualElementImpl->GetChildrenTransformMatrix();
 318 }
 319
 320 result
 321 VisualElement::SetChildrenTransformMatrix(const Tizen::Graphics::FloatMatrix4& transform)
 322 {
 323         CHECK_CONSTRUCTED;
 324
 325         return _pVisualElementImpl->SetChildrenTransformMatrix(transform);
 326 }
 327
 328 FloatPoint
 329 VisualElement::GetAnchor(void) const
 330 {
 331         CHECK_CONSTRUCTED;
 332
 333         return _pVisualElementImpl->GetAnchor();
 334 }
 335
 336 void
 337 VisualElement::SetAnchor(const FloatPoint& anchor)
 338 {
 339         CHECK_CONSTRUCTED;
 340
 341         _pVisualElementImpl->SetAnchor(anchor);
 342 }
 343
 344 float
 345 VisualElement::GetAnchorZ(void) const
 346 {
 347         CHECK_CONSTRUCTED;
 348
 349         return _pVisualElementImpl->GetAnchorZ();
 350 }
 351
 352 void
 353 VisualElement::SetAnchorZ(float anchorZ)
 354 {
 355         CHECK_CONSTRUCTED;
 356
 357         _pVisualElementImpl->SetAnchorZ(anchorZ);
 358
 359 }
 360
 361 VisualElement*
 362 VisualElement::GetParent(void) const
 363 {
 364         CHECK_CONSTRUCTED;
 365
 366         if (_pVisualElementImpl->__isHidingParent)
 367         {
 368                 return null;
 369         }
 370
 371         if (_pVisualElementImpl->GetParent() && !_pVisualElementImpl->GetParent()->__isInternal)
 372         {
 373                 return _pVisualElementImpl->GetParent()->GetPublic();
 374         }
 375         else
 376         {
 377                 return null;
 378         }
 379 }
 380
 381 Tizen::Base::Collection::IList*
 382 VisualElement::GetChildrenN(void) const
 383 {
 384         CHECK_CONSTRUCTED;
 385
 386         return _pVisualElementImpl->GetPublicChildrenN();
 387 }
 388
 389 int
 390 VisualElement::GetChildrenCount(void) const
 391 {
 392         CHECK_CONSTRUCTED;
 393
 394         return  _pVisualElementImpl->GetChildrenCount();
 395 }
 396
 397 bool
 398 VisualElement::IsChildOf(const VisualElement& element) const
 399 {
 400         CHECK_CONSTRUCTED;
 401         CHECK_PARAMETER_CONSTRUCTED(element);
 402
 403         return _pVisualElementImpl->IsChildOf(*element._pVisualElementImpl);
 404 }
 405
 406 result
 407 VisualElement::AttachChild(const VisualElement& child)
 408 {
 409         CHECK_CONSTRUCTED;
 410         CHECK_PARAMETER_CONSTRUCTED(child);
 411
 412         return _pVisualElementImpl->AddChild(*child._pVisualElementImpl);
 413 }
 414
 415 result
 416 VisualElement::InsertChild(const VisualElement& child, const VisualElement* pReference, bool above)
 417 {
 418         CHECK_CONSTRUCTED;
 419         CHECK_PARAMETER_CONSTRUCTED(child);
 420
 421         _VisualElementImpl* pRefInternal = null;
 422         if (pReference)
 423         {
 424                 CHECK_PARAMETER_CONSTRUCTED(*pReference);
 425                 pRefInternal = pReference->_pVisualElementImpl;
 426         }
 427
 428         return _pVisualElementImpl->InsertChild(*child._pVisualElementImpl, pRefInternal, above);
 429 }
 430
 431 result
 432 VisualElement::DetachChild(const VisualElement& child)
 433 {
 434         CHECK_CONSTRUCTED;
 435         CHECK_PARAMETER_CONSTRUCTED(child);
 436
 437         _VisualElementImpl* pInternal = null;
 438
 439         pInternal = child._pVisualElementImpl;
 440
 441         return _pVisualElementImpl->RemoveChild(*pInternal, false);
 442 }
 443
 444 result
 445 VisualElement::ChangeZOrder(const VisualElement* pReference, bool above)
 446 {
 447         CHECK_CONSTRUCTED;
 448
 449         _VisualElementImpl* pRefInternal = null;
 450         if (pReference)
 451         {
 452                 CHECK_PARAMETER_CONSTRUCTED(*pReference);
 453                 pRefInternal = pReference->_pVisualElementImpl;
 454         }
 455
 456         return _pVisualElementImpl->SetZOrder(pRefInternal, above);
 457 }
 458
 459 result
 460 VisualElement::SetAnimationProvider(IVisualElementAnimationProvider* pProvider)
 461 {
 462         CHECK_CONSTRUCTED;
 463
 464         return _pVisualElementImpl->SetAnimationProvider(pProvider);
 465 }
 466
 467
 468 IVisualElementAnimationProvider*
 469 VisualElement::GetAnimationProvider(void) const
 470 {
 471         CHECK_CONSTRUCTED;
 472
 473         return _pVisualElementImpl->GetAnimationProvider();
 474 }
 475
 476 result
 477 VisualElement::SetContentProvider(IVisualElementContentProvider* pProvider)
 478 {
 479         CHECK_CONSTRUCTED;
 480
 481         return _pVisualElementImpl->SetContentProvider(pProvider);
 482 }
 483
 484 IVisualElementContentProvider*
 485 VisualElement::GetContentProvider(void) const
 486 {
 487         CHECK_CONSTRUCTED;
 488
 489         return _pVisualElementImpl->GetContentProvider();
 490 }
 491
 492
 493 result
 494 VisualElement::SetVisualElementEventListener(IVisualElementEventListener* pListener)
 495 {
 496         CHECK_CONSTRUCTED;
 497
 498         return _pVisualElementImpl->SetVisualElementEventListener(pListener);
 499 }
 500
 501 IVisualElementEventListener*
 502 VisualElement::GetVisualElementEventListener(void) const
 503 {
 504         CHECK_CONSTRUCTED;
 505
 506         return _pVisualElementImpl->GetVisualElementEventListener();
 507 }
 508
 509
 510 Tizen::Base::String
 511 VisualElement::GetName(void) const
 512 {
 513         CHECK_CONSTRUCTED;
 514
 515         return _pVisualElementImpl->GetName();
 516 }
 517
 518 void
 519 VisualElement::SetName(const Tizen::Base::String& name)
 520 {
 521         CHECK_CONSTRUCTED;
 522
 523         _pVisualElementImpl->SetName(name);
 524 }
 525
 526 void
 527 VisualElement::SetUserData(void* pUserData)
 528 {
 529         CHECK_CONSTRUCTED;
 530
 531         _pVisualElementImpl->SetUserData(pUserData);
 532 }
 533
 534 void*
 535 VisualElement::GetUserData(void) const
 536 {
 537         CHECK_CONSTRUCTED;
 538
 539         return _pVisualElementImpl->GetUserData();
 540 }
 541
 542 result
 543 VisualElement::SetSurface(VisualElementSurface* pSurface)
 544 {
 545         CHECK_CONSTRUCTED;
 546
 547         return _pVisualElementImpl->SetSurface(pSurface);
 548 }
 549
 550 VisualElementSurface*
 551 VisualElement::GetSurfaceN(void) const
 552 {
 553         CHECK_CONSTRUCTED;
 554
 555         return _pVisualElementImpl->GetSurfaceN();
 556 }
 557
 558 result
 559 VisualElement::SetRenderOperation(RenderOperation renderOperation)
 560 {
 561         CHECK_CONSTRUCTED;
 562
 563         return _pVisualElementImpl->SetRenderOperation(renderOperation);
 564 }
 565
 566 VisualElement::RenderOperation
 567 VisualElement::GetRenderOperation(void) const
 568 {
 569         CHECK_CONSTRUCTED;
 570
 571         return _pVisualElementImpl->GetRenderOperation();
 572 }
 573
 574 VisualElement*
 575 VisualElement::GetChild(const Tizen::Base::String& name, bool searchDescendants) const
 576 {
 577         CHECK_CONSTRUCTED;
 578
 579         _VisualElementImpl* pChild = _pVisualElementImpl->GetChild(name, searchDescendants);
 580         if (pChild)
 581         {
 582                 return pChild->GetPublic();
 583         }
 584
 585         return null;
 586 }
 587
 588 result
 589 VisualElement::InvalidateRectangle(const FloatRectangle* pRectangle)
 590 {
 591         CHECK_CONSTRUCTED;
 592
 593         return _pVisualElementImpl->InvalidateRectangle(pRectangle);
 594 }
 595
 596 FloatRectangle
 597 VisualElement::GetUpdateRectangle(void) const
 598 {
 599         CHECK_CONSTRUCTED;
 600
 601         return _pVisualElementImpl->GetUpdateRectangle();
 602 }
 603
 604 result
 605 VisualElement::Draw(void)
 606 {
 607         CHECK_CONSTRUCTED;
 608
 609         return _pVisualElementImpl->Draw();
 610 }
 611
 612 Canvas*
 613 VisualElement::GetCanvasN(void) const
 614 {
 615         CHECK_CONSTRUCTED;
 616
 617         return _pVisualElementImpl->GetCanvasN();
 618 }
 619
 620 Canvas*
 621 VisualElement::GetCanvasN(const Tizen::Graphics::Rectangle& bounds) const
 622 {
 623         CHECK_CONSTRUCTED;
 624
 625         return _pVisualElementImpl->GetCanvasN(bounds);
 626 }
 627
 628 VisualElement*
 629 VisualElement::GetChildAt(const FloatPoint& point) const
 630 {
 631         CHECK_CONSTRUCTED;
 632
 633         _VisualElementImpl* pChild = _pVisualElementImpl->GetChildAt(point);
 634         if (pChild)
 635         {
 636                 return pChild->GetPublic();
 637         }
 638
 639         return null;
 640 }
 641
 642 bool
 643 VisualElement::IsClipChildrenEnabled(void) const
 644 {
 645         CHECK_CONSTRUCTED;
 646
 647         return _pVisualElementImpl->IsClipChildrenEnabled();
 648 }
 649
 650 void
 651 VisualElement::SetClipChildrenEnabled(bool clipChildren)
 652 {
 653         CHECK_CONSTRUCTED;
 654
 655         _pVisualElementImpl->SetClipChildrenEnabled(clipChildren);
 656 }
 657
 658 result
 659 VisualElement::ConvertCoordinates(FloatPoint& point, const VisualElement* pFromVisualElement) const
 660 {
 661         CHECK_CONSTRUCTED;
 662
 663         _VisualElementImpl* pFrom = null;
 664
 665         if (pFromVisualElement)
 666         {
 667                 CHECK_PARAMETER_CONSTRUCTED(*pFromVisualElement);
 668                 pFrom = pFromVisualElement->_pVisualElementImpl;
 669         }
 670
 671         return _pVisualElementImpl->ConvertCoordinates(point, pFrom);
 672 }
 673
 674 result
 675 VisualElement::ConvertCoordinates(FloatRectangle& rectangle, const VisualElement* pFromVisualElement) const
 676 {
 677         CHECK_CONSTRUCTED;
 678
 679         _VisualElementImpl* pFrom = null;
 680
 681         if (pFromVisualElement)
 682         {
 683                 CHECK_PARAMETER_CONSTRUCTED(*pFromVisualElement);
 684                 pFrom = pFromVisualElement->_pVisualElementImpl;
 685         }
 686
 687         return _pVisualElementImpl->ConvertCoordinates(rectangle, pFrom);
 688 }
 689
 690 result
 691 VisualElement::SetContentBounds(const FloatRectangle& contentBounds)
 692 {
 693         CHECK_CONSTRUCTED;
 694
 695         return _pVisualElementImpl->SetContentBounds(contentBounds);
 696 }
 697
 698 FloatRectangle
 699 VisualElement::GetContentBounds(void) const
 700 {
 701         CHECK_CONSTRUCTED;
 702
 703         return _pVisualElementImpl->GetContentBounds();
 704 }
 705
 706
 707 result
 708 VisualElement::AddAnimation(const VisualElementAnimation& animation)
 709 {
 710         CHECK_CONSTRUCTED;
 711
 712         return _pVisualElementImpl->AddAnimation(null, const_cast< VisualElementAnimation& >(animation));
 713 }
 714
 715 result
 716 VisualElement::AddAnimation(const Tizen::Base::String& keyName, const VisualElementAnimation& animation)
 717 {
 718         CHECK_CONSTRUCTED;
 719
 720         return _pVisualElementImpl->AddAnimation(&keyName, const_cast< VisualElementAnimation& >(animation));
 721 }
 722
 723
 724 result
 725 VisualElement::RemoveAnimation(const Tizen::Base::String& keyName)
 726 {
 727         CHECK_CONSTRUCTED;
 728
 729         return _pVisualElementImpl->RemoveAnimation(keyName);
 730 }
 731
 732 VisualElementAnimation*
 733 VisualElement::GetAnimationN(const Tizen::Base::String& keyName) const
 734 {
 735         CHECK_CONSTRUCTED;
 736
 737         return _pVisualElementImpl->GetAnimationN(keyName);
 738 }
 739
 740 void
 741 VisualElement::RemoveAllAnimations(void)
 742 {
 743         CHECK_CONSTRUCTED;
 744
 745         _pVisualElementImpl->RemoveAllAnimations();
 746 }
 747
 748 const VisualElement*
 749 VisualElement::AcquirePresentationInstance(void)
 750 {
 751         CHECK_CONSTRUCTED;
 752
 753         if (likely(_pVisualElementImpl->GetPresentation()))
 754         {
 755                 return _pVisualElementImpl->GetPresentation()->GetPublic();
 756         }
 757
 758         return null;
 759 }
 760
 761 void
 762 VisualElement::ReleasePresentationInstance(void)
 763 {
 764         return;
 765 }
 766
 767 const VisualElement*
 768 VisualElement::AcquireModelInstance(void)
 769 {
 770         CHECK_CONSTRUCTED;
 771
 772         if (likely(_pVisualElementImpl->GetModel()))
 773         {
 774                 return _pVisualElementImpl->GetModel()->GetPublic();
 775         }
 776
 777         return null;
 778 }
 779
 780 void
 781 VisualElement::ReleaseModelInstance(void)
 782 {
 783         return;
 784 }
 785
 786 void
 787 VisualElement::SetImplicitAnimationEnabled(bool enable)
 788 {
 789         CHECK_CONSTRUCTED;
 790
 791         _pVisualElementImpl->SetImplicitAnimationEnabled(enable);
 792 }
 793
 794 bool
 795 VisualElement::IsImplicitAnimationEnabled(void) const
 796 {
 797         CHECK_CONSTRUCTED;
 798
 799         return _pVisualElementImpl->GetImplicitAnimationEnabled();
 800 }
 801
 802 // Delegations
 803 void
 804 VisualElement::OnConstructed(void)
 805 {
 806
 807 }
 808
 809 /**
 810  * This method is invoked before deallocating the VisualElement instance in the Destroy() method.
 811  * @since 2.0
 812  *
 813  * @see Destroy()
 814  * @see Construct()
 815  * @see OnConstructed()
 816  */
 817 void
 818 VisualElement::OnDestructing(void)
 819 {
 820 }
 821
 822 HitTestResult
 823 VisualElement::OnHitTest(const FloatPoint& point)
 824 {
 825         CHECK_CONSTRUCTED;
 826
 827         int hitResult = _pVisualElementImpl->HitTestI(point);
 828
 829         if (hitResult == _VisualElementImpl::HITTEST_MATCH)
 830         {
 831                 return HIT_TEST_MATCH;
 832         }
 833
 834         return HIT_TEST_NOWHERE;
 835 }
 836
 837 bool
 838 VisualElement::OnPrepareDraw(void)
 839 {
 840         return true;
 841 }
 842
 843 result
 844 VisualElement::SetFlushNeeded(void)
 845 {
 846         CHECK_CONSTRUCTED;
 847
 848         return _pVisualElementImpl->SetFlushNeeded();
 849 }
 850
 851 result
 852 VisualElement::Flush(void)
 853 {
 854         return _VisualElementImpl::FlushI();
 855 }
 856
 857 void
 858 VisualElement::OnDraw(Canvas& canvas)
 859 {
 860 }
 861
 862 VisualElementAnimation*
 863 VisualElement::OnCreateAnimationForProperty(const Tizen::Base::String& property)
 864 {
 865         CHECK_CONSTRUCTED;
 866
 867         return _pVisualElementImpl->CreateAnimationForPropertyI(property);
 868 }
 869
 870
 871 }}}             // Tizen::Ui::Animations
 872