src/ui/controls/FUiCtrl_ScrollPanel.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0/
  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        FUiCtrl_ScrollPanel.cpp
  20  * @brief       This is the implementation file for the %_ScrollPanel class.
  21  *
  22  */
  23
  24 #include <FBaseErrorDefine.h>
  25 #include <FBaseSysLog.h>
  26 #include <FUiIScrollPanelEventListener.h>
  27 #include <FUiAnimVisualElementAnimation.h>
  28 #include <FUiAnimVisualElementValueAnimation.h>
  29 #include "FUiAnim_VisualElement.h"
  30 #include "FUi_TouchFlickGestureDetector.h"
  31 #include "FUiCtrl_UiScrollEvent.h"
  32 #include "FUiCtrl_UiScrollEventArg.h"
  33 #include "FUiCtrl_Scroll.h"
  34 #include "FUiCtrl_ScrollPanelPresenter.h"
  35 #include "FUiCtrl_ScrollPanel.h"
  36
  37 using namespace Tizen::Base;
  38 using namespace Tizen::Graphics;
  39 using namespace Tizen::Ui::Animations;
  40
  41 namespace
  42 {
  43 const int SCROLL_PANEL_ANIMATION_DEFAULT_REPEAT_COUNT = 1;
  44 }
  45
  46 namespace Tizen { namespace Ui { namespace Controls
  47 {
  48 _ScrollPanel::_ScrollPanel(void)
  49         : _Panel()
  50         , __pScrollPanelPresenter(null)
  51         , __pScrollEvent(null)
  52         , __pCoreScrollPanelEvent(null)
  53         , __pGestureFlick(null)
  54         , __pKeyPadBindingControl(null)
  55         , __scrollDirection(SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL)
  56         , __scrollInputMode(SCROLL_INPUT_MODE_ALLOW_ANY_DIRECTION)
  57         , __autoResizingEnable(true)
  58         , __pageScrollEnabled(false)
  59         , __pageScrollAlignSize(FloatDimension(0.0f, 0.0f))
  60         , __pageScrollMoveOnlyOnePageOnFlick(true)
  61         , __scrollBarVisible(true)
  62         , __pHorizontalScrollBar(null)
  63         , __pVerticalScrollBar(null)
  64         , __pScrollingAnimation(null)
  65         , __fixingClientBoundsEnable(true)
  66 {
  67         // nothing
  68 }
  69
  70
  71 _ScrollPanel::~_ScrollPanel(void)
  72 {
  73         _ControlManager* pControlManager = _ControlManager::GetInstance();
  74         SysTryReturnVoidResult(NID_UI_CTRL, pControlManager, E_SYSTEM, "[%s] System error occurred.", GetErrorMessage(E_SYSTEM));
  75
  76         if (GetVisualElement() != null)
  77         {
  78                 __pScrollingAnimation->SetVisualElementAnimationTickEventListener(null);
  79                 __pScrollingAnimation->SetVisualElementAnimationStatusEventListener(null);
  80                 GetVisualElement()->RemoveAllAnimations();
  81         }
  82
  83         if (__pGestureFlick != null)
  84         {
  85                 __pGestureFlick->RemoveGestureListener(*this);
  86                 pControlManager->RemoveGestureDetector(*__pGestureFlick);
  87                 RemoveGestureDetector(*__pGestureFlick);
  88                 delete __pGestureFlick;
  89                 __pGestureFlick = null;
  90         }
  91
  92         delete __pScrollEvent;
  93         __pScrollEvent = null;
  94
  95         if (__pVerticalScrollBar != null && IsAncestorOf(*__pVerticalScrollBar))
  96         {
  97                 DetachSystemChild(*__pVerticalScrollBar);
  98         }
  99         delete __pVerticalScrollBar;
 100         __pVerticalScrollBar = null;
 101
 102         if (__pHorizontalScrollBar != null && IsAncestorOf(*__pHorizontalScrollBar))
 103         {
 104                 DetachSystemChild(*__pHorizontalScrollBar);
 105         }
 106         delete __pHorizontalScrollBar;
 107         __pHorizontalScrollBar = null;
 108
 109         delete __pScrollingAnimation;
 110         __pScrollingAnimation = null;
 111
 112         _Panel::SetPanelPresenter(null);
 113         delete __pScrollPanelPresenter;
 114         __pScrollPanelPresenter = null;
 115 }
 116
 117 _ScrollPanel*
 118 _ScrollPanel::CreateScrollPanelN(const FloatRectangle& rect, ScrollPanelScrollDirection scrollDirection, bool autoResizingEnable, bool pageScrollEnabled)
 119 {
 120         ClearLastResult();
 121         result r = E_SUCCESS;
 122
 123         _Scroll* pHorizontalScrollBar = null;
 124         _Scroll* pVerticalScrollBar = null;
 125
 126         FloatRectangle areaBounds(0.0f, 0.0f, rect.width, rect.height);
 127
 128         _ScrollPanel* pScrollPanel = new (std::nothrow) _ScrollPanel;
 129         SysTryReturn(NID_UI_CTRL, pScrollPanel != null, null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 130
 131         pScrollPanel->SetScrollDirection(scrollDirection);
 132         pScrollPanel->SetScrollAreaAutoResizingEnabled(autoResizingEnable);
 133         pScrollPanel->SetPageScrollEnabled(pageScrollEnabled);
 134
 135         _ScrollPanelPresenter* pPresenter = new (std::nothrow) _ScrollPanelPresenter;
 136         SysTryCatch(NID_UI_CTRL, pPresenter != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 137
 138         r = pPresenter->Initialize(*pScrollPanel);
 139         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 140
 141         r = pScrollPanel->Initialize(*pPresenter);
 142         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 143
 144         pPresenter->SetScrollAreaBoundsInternal(areaBounds);
 145         r = GetLastResult();
 146         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 147
 148         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL && rect.height > 0.0f)
 149         {
 150                 pVerticalScrollBar = _Scroll::CreateScrollN(*pScrollPanel,
 151                                                                                 SCROLL_DIRECTION_VERTICAL,
 152                                                                                 true,
 153                                                                                 false,
 154                                                                                 false,
 155                                                                                 false,
 156                                                                                 rect.height,
 157                                                                                 rect.height,
 158                                                                                 0.0f);
 159                 r = GetLastResult();
 160                 SysTryCatch(NID_UI_CTRL, r ==E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 161
 162                 pVerticalScrollBar->EnableScrollingEffect(true);
 163
 164                 pVerticalScrollBar->AddScrollEventListener(*pScrollPanel);
 165                 r = GetLastResult();
 166                 SysTryCatch(NID_UI_CTRL, r ==E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 167
 168                 r = pScrollPanel->AttachSystemChild(*pVerticalScrollBar);
 169                 SysTryCatch(NID_UI_CTRL, r ==E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 170
 171                 pScrollPanel->SetVerticalScrollBar(pVerticalScrollBar);
 172         }
 173
 174         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL && rect.width > 0.0f)
 175         {
 176                 pHorizontalScrollBar = _Scroll::CreateScrollN(*pScrollPanel,
 177                                                                                 SCROLL_DIRECTION_HORIZONTAL,
 178                                                                                 true,
 179                                                                                 false,
 180                                                                                 false,
 181                                                                                 false,
 182                                                                                 rect.width,
 183                                                                                 rect.width,
 184                                                                                 0.0f);
 185                 r = GetLastResult();
 186                 SysTryCatch(NID_UI_CTRL, r ==E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 187
 188                 pHorizontalScrollBar->EnableScrollingEffect(true);
 189
 190                 pHorizontalScrollBar->AddScrollEventListener(*pScrollPanel);
 191                 r = GetLastResult();
 192                 SysTryCatch(NID_UI_CTRL, r ==E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 193
 194                 r = pScrollPanel->AttachSystemChild(*pHorizontalScrollBar);
 195                 SysTryCatch(NID_UI_CTRL, r ==E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 196
 197                 pScrollPanel->SetHorizontalScrollBar(pHorizontalScrollBar);
 198         }
 199
 200         r = pScrollPanel->SetBounds(rect);
 201         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 202
 203         return pScrollPanel;
 204
 205 CATCH:
 206         if (pHorizontalScrollBar != null && pScrollPanel->IsAncestorOf(*pHorizontalScrollBar))
 207         {
 208                 pScrollPanel->DetachSystemChild(*pHorizontalScrollBar);
 209         }
 210         delete pHorizontalScrollBar;
 211         pScrollPanel->__pHorizontalScrollBar = null;
 212
 213         if (pVerticalScrollBar != null && pScrollPanel->IsAncestorOf(*pVerticalScrollBar))
 214         {
 215                 pScrollPanel->DetachSystemChild(*pVerticalScrollBar);
 216         }
 217         delete pVerticalScrollBar;
 218         pScrollPanel->__pVerticalScrollBar = null;
 219
 220         delete pPresenter;
 221         pScrollPanel->__pScrollPanelPresenter = null;
 222
 223         delete pScrollPanel;
 224
 225         SetLastResult(r);
 226         return null;
 227 }
 228
 229 result
 230 _ScrollPanel::Initialize(const _ScrollPanelPresenter& presenter, bool acquireHandle)
 231 {
 232         ClearLastResult();
 233
 234         result r = _Panel::Initialize(presenter);
 235         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 236
 237         SetScrollPanelPresenter(&presenter);
 238
 239         __pScrollingAnimation = new (std::nothrow) VisualElementValueAnimation;
 240         SysTryReturn(NID_UI_CTRL, __pScrollingAnimation != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 241
 242         __pScrollingAnimation->SetRepeatCount(SCROLL_PANEL_ANIMATION_DEFAULT_REPEAT_COUNT);
 243         __pScrollingAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseOut"));
 244         r = GetLastResult();
 245         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 246
 247         __pScrollingAnimation->SetVisualElementAnimationTickEventListener(this);
 248         r = GetLastResult();
 249         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 250
 251         __pScrollingAnimation->SetVisualElementAnimationStatusEventListener(this);
 252         r = GetLastResult();
 253         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 254
 255         __pGestureFlick = new (std::nothrow) _TouchFlickGestureDetector;
 256         SysTryCatch(NID_UI_CTRL, __pGestureFlick != null, , E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 257         r = GetLastResult();
 258         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 259
 260         if (acquireHandle)
 261         {
 262                 AcquireHandle();
 263         }
 264
 265         r = AddGestureDetector(*__pGestureFlick);
 266         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 267
 268         r = __pGestureFlick->AddGestureListener(*this);
 269         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 270
 271         return r;
 272
 273 CATCH:
 274         delete __pGestureFlick;
 275         __pGestureFlick = null;
 276
 277         delete __pScrollingAnimation;
 278         __pScrollingAnimation = null;
 279
 280         SetLastResult(r);
 281         return r;
 282 }
 283
 284 result
 285 _ScrollPanel::SetScrollPanelPresenter(const _ScrollPanelPresenter* presenter)
 286 {
 287         ClearLastResult();
 288
 289         _Panel::SetPanelPresenter(presenter);
 290         __pScrollPanelPresenter = const_cast <_ScrollPanelPresenter*>(presenter);
 291
 292         return E_SUCCESS;
 293 }
 294
 295 void
 296 _ScrollPanel::OnDraw(void)
 297 {
 298         ClearLastResult();
 299
 300         if (__pScrollPanelPresenter == null)
 301         {
 302                 return;
 303         }
 304
 305         result r = __pScrollPanelPresenter->Draw();
 306         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 307 }
 308
 309 result
 310 _ScrollPanel::OnBoundsChanging(const Tizen::Graphics::FloatRectangle& bounds)
 311 {
 312         ClearLastResult();
 313
 314         return __pScrollPanelPresenter->OnBoundsChanging(bounds);
 315 }
 316
 317 void
 318 _ScrollPanel::OnBoundsChanged(void)
 319 {
 320         ClearLastResult();
 321
 322         if (__pScrollPanelPresenter == null)
 323         {
 324                 return;
 325         }
 326
 327         __pScrollPanelPresenter->OnBoundsChanged();
 328 }
 329
 330 void
 331 _ScrollPanel::OnChildAttached(const _Control& child)
 332 {
 333         ClearLastResult();
 334
 335         if (__pScrollPanelPresenter == null)
 336         {
 337                 return;
 338         }
 339
 340         __pScrollPanelPresenter->OnChildAttached(child);
 341 }
 342
 343 void
 344 _ScrollPanel::OnChildDetached(const _Control& child)
 345 {
 346         ClearLastResult();
 347
 348         if (__pScrollPanelPresenter == null)
 349         {
 350                 return;
 351         }
 352
 353         __pScrollPanelPresenter->OnChildDetached(child);
 354 }
 355
 356 void
 357 _ScrollPanel::OnChildBoundsChanged(const _Control& child)
 358 {
 359         ClearLastResult();
 360
 361         if (__pScrollPanelPresenter == null)
 362         {
 363                 return;
 364         }
 365
 366         __pScrollPanelPresenter->OnChildBoundsChanged(child);
 367 }
 368
 369 bool
 370 _ScrollPanel::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 371 {
 372         ClearLastResult();
 373
 374         return __pScrollPanelPresenter->OnFlickGestureDetected(gesture);
 375 }
 376
 377 bool
 378 _ScrollPanel::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 379 {
 380         ClearLastResult();
 381
 382         return __pScrollPanelPresenter->OnFlickGestureCanceled(gesture);
 383 }
 384
 385 bool
 386 _ScrollPanel::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 387 {
 388         ClearLastResult();
 389
 390         return __pScrollPanelPresenter->OnAccessibilityFocusMovedNext(control, element);
 391 }
 392
 393 bool
 394 _ScrollPanel::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 395 {
 396         ClearLastResult();
 397
 398         return __pScrollPanelPresenter->OnAccessibilityFocusMovedPrevious(control, element);
 399 }
 400
 401 bool
 402 _ScrollPanel::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 403 {
 404         ClearLastResult();
 405
 406         return __pScrollPanelPresenter->OnAccessibilityReadingElement(control, element);
 407 }
 408 bool
 409 _ScrollPanel::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 410 {
 411         ClearLastResult();
 412
 413         return __pScrollPanelPresenter->OnAccessibilityReadElement(control, element);
 414 }
 415
 416 bool
 417 _ScrollPanel::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 418 {
 419         ClearLastResult();
 420
 421         return __pScrollPanelPresenter->OnAccessibilityFocusIn(control, element);
 422 }
 423
 424 bool
 425 _ScrollPanel::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 426 {
 427         ClearLastResult();
 428
 429         return __pScrollPanelPresenter->OnAccessibilityFocusOut(control, element);
 430 }
 431
 432 bool
 433 _ScrollPanel::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 434 {
 435         ClearLastResult();
 436
 437         return __pScrollPanelPresenter->OnAccessibilityActionPerformed(control, element);
 438 }
 439 bool
 440 _ScrollPanel::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 441 {
 442         return false;
 443 }
 444 bool
 445 _ScrollPanel::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 446 {
 447         return false;
 448 }
 449
 450 void
 451 _ScrollPanel::OnChildControlFocusMoved(const _Control& control)
 452 {
 453         ClearLastResult();
 454
 455         __pScrollPanelPresenter->OnChildControlFocusMoved(control);
 456 }
 457
 458 void
 459 _ScrollPanel::OnDescendantControlFocusMoved(const _Control& control)
 460 {
 461         ClearLastResult();
 462
 463         __pScrollPanelPresenter->OnDescendantControlFocusMoved(control);
 464 }
 465
 466 bool
 467 _ScrollPanel::OnAccessibilityItemRefreshed(const _AccessibilityContainer& control, const _AccessibilityElement& element, _AccessibilityFocusDirection direction)
 468 {
 469         ClearLastResult();
 470
 471         return __pScrollPanelPresenter->OnAccessibilityItemRefreshed(control, element, direction);
 472 }
 473 _UiTouchEventDelivery
 474 _ScrollPanel::OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 475 {
 476         ClearLastResult();
 477
 478         return __pScrollPanelPresenter->OnPreviewTouchPressed(source, touchinfo);
 479 }
 480
 481 _UiTouchEventDelivery
 482 _ScrollPanel::OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 483 {
 484         ClearLastResult();
 485
 486         return __pScrollPanelPresenter->OnPreviewTouchMoved(source, touchinfo);
 487 }
 488
 489 _UiTouchEventDelivery
 490 _ScrollPanel::OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 491 {
 492         ClearLastResult();
 493
 494         return __pScrollPanelPresenter->OnPreviewTouchReleased(source, touchinfo);
 495 }
 496
 497 _UiTouchEventDelivery
 498 _ScrollPanel::OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 499 {
 500         ClearLastResult();
 501
 502         return __pScrollPanelPresenter->OnPreviewTouchCanceled(source, touchinfo);
 503 }
 504
 505 bool
 506 _ScrollPanel::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 507 {
 508         ClearLastResult();
 509
 510         return __pScrollPanelPresenter->OnTouchPressed(source, touchinfo);
 511 }
 512
 513 bool
 514 _ScrollPanel::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 515 {
 516         ClearLastResult();
 517
 518         return __pScrollPanelPresenter->OnTouchMoved(source, touchinfo);
 519 }
 520
 521 bool
 522 _ScrollPanel::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 523 {
 524         ClearLastResult();
 525
 526         return __pScrollPanelPresenter->OnTouchReleased(source, touchinfo);
 527 }
 528
 529 bool
 530 _ScrollPanel::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 531 {
 532         ClearLastResult();
 533
 534         return __pScrollPanelPresenter->OnTouchCanceled(source, touchinfo);
 535 }
 536
 537 void
 538 _ScrollPanel::OnTouchMoveHandled(const _Control& control)
 539 {
 540         ClearLastResult();
 541
 542         return __pScrollPanelPresenter->OnTouchMoveHandled(control);
 543 }
 544
 545 void
 546 _ScrollPanel::OnScrollEndReached(_Control& source, ScrollEndEvent type)
 547 {
 548         ClearLastResult();
 549
 550         __pScrollPanelPresenter->OnScrollEndReached(source, type);
 551 }
 552
 553 void
 554 _ScrollPanel::OnScrollPositionChanged(_Control& source, float scrollPosition)
 555 {
 556         ClearLastResult();
 557
 558         __pScrollPanelPresenter->OnScrollPositionChanged(source, scrollPosition);
 559 }
 560
 561 void
 562 _ScrollPanel::OnScrollStopped(_Control& source)
 563 {
 564         ClearLastResult();
 565
 566         __pScrollPanelPresenter->OnScrollStopped(source);
 567 }
 568
 569 void
 570 _ScrollPanel::OnScrollJumpToTop(_Control& source)
 571 {
 572         ClearLastResult();
 573
 574         __pScrollPanelPresenter->OnScrollJumpToTop(source);
 575 }
 576
 577 void
 578 _ScrollPanel::OnVisualElementAnimationStarted(const VisualElementAnimation& animation, const String& keyName, VisualElement& target)
 579 {
 580         ClearLastResult();
 581
 582         if (__pScrollPanelPresenter == null)
 583         {
 584                 return;
 585         }
 586
 587         __pScrollPanelPresenter->OnVisualElementAnimationStarted(animation, keyName, target);
 588 }
 589
 590 void
 591 _ScrollPanel::OnVisualElementAnimationRepeated(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, long currentRepeatCount)
 592 {
 593         ClearLastResult();
 594
 595         if (__pScrollPanelPresenter == null)
 596         {
 597                 return;
 598         }
 599
 600         __pScrollPanelPresenter->OnVisualElementAnimationRepeated(animation, keyName, target, currentRepeatCount);
 601 }
 602
 603 void
 604 _ScrollPanel::OnVisualElementAnimationFinished(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, bool completedNormally)
 605 {
 606         ClearLastResult();
 607
 608         if (__pScrollPanelPresenter == null)
 609         {
 610                 return;
 611         }
 612
 613         __pScrollPanelPresenter->OnVisualElementAnimationFinished(animation, keyName, target, completedNormally);
 614 }
 615
 616 void
 617 _ScrollPanel::OnTickOccurred(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, const Variant& currentValue)
 618 {
 619         ClearLastResult();
 620
 621         __pScrollPanelPresenter->OnTickOccurred(animation, keyName, target, currentValue);
 622 }
 623
 624 bool
 625 _ScrollPanel::IsScrollAreaAutoResizingEnabled(void) const
 626 {
 627         ClearLastResult();
 628
 629         return __autoResizingEnable;
 630 }
 631
 632 void
 633 _ScrollPanel::SetScrollAreaAutoResizingEnabled(bool autoResizingEnable)
 634 {
 635         ClearLastResult();
 636
 637         __autoResizingEnable = autoResizingEnable;
 638 }
 639
 640 FloatRectangle
 641 _ScrollPanel::GetScrollAreaBounds(void) const
 642 {
 643         ClearLastResult();
 644
 645         return __pScrollPanelPresenter->GetScrollAreaBounds();
 646 }
 647
 648 result
 649 _ScrollPanel::SetClientAreaHeight(float height)
 650 {
 651         ClearLastResult();
 652
 653         return __pScrollPanelPresenter->SetClientAreaHeight(height);
 654 }
 655
 656 result
 657 _ScrollPanel::SetClientAreaWidth(float width)
 658 {
 659         ClearLastResult();
 660
 661         return __pScrollPanelPresenter->SetClientAreaWidth(width);
 662 }
 663
 664 result
 665 _ScrollPanel::SetScrollAreaBounds(FloatRectangle& bounds)
 666 {
 667         ClearLastResult();
 668
 669         return __pScrollPanelPresenter->SetScrollAreaBounds(bounds);
 670 }
 671
 672 void
 673 _ScrollPanel::UpdateClientBounds(const FloatDimension& size, FloatRectangle& clientBounds)
 674 {
 675         ClearLastResult();
 676
 677         if (IsFixingClientBoundsEnabled())
 678         {
 679                 __pScrollPanelPresenter->UpdateClientBounds(size, clientBounds);
 680         }
 681         else
 682         {
 683                 _Panel::UpdateClientBounds(size, clientBounds);
 684         }
 685 }
 686
 687 bool
 688 _ScrollPanel::IsPageScrollEnabled(void) const
 689 {
 690         ClearLastResult();
 691
 692         return __pageScrollEnabled;
 693 }
 694
 695 void
 696 _ScrollPanel::SetPageScrollEnabled(bool enable)
 697 {
 698         ClearLastResult();
 699
 700         __pageScrollEnabled = enable;
 701 }
 702
 703 FloatDimension
 704 _ScrollPanel::GetPageScrollAlignSize(void) const
 705 {
 706         ClearLastResult();
 707
 708         return __pageScrollAlignSize;
 709 }
 710
 711 void
 712 _ScrollPanel::SetPageScrollAlignSize(FloatDimension size)
 713 {
 714         ClearLastResult();
 715
 716         __pageScrollAlignSize = size;
 717 }
 718
 719 bool
 720 _ScrollPanel::IsPageScrollFlickMoveLimitedOnePage(void) const
 721 {
 722         return __pageScrollMoveOnlyOnePageOnFlick;
 723 }
 724
 725 void
 726 _ScrollPanel::SetScrollPosition(float position, bool withAnimation)
 727 {
 728         ClearLastResult();
 729
 730         __pScrollPanelPresenter->SetScrollPosition(position, withAnimation);
 731 }
 732
 733 void
 734 _ScrollPanel::SetScrollPosition(Tizen::Graphics::FloatPoint position, bool withAnimation)
 735 {
 736         ClearLastResult();
 737
 738         __pScrollPanelPresenter->SetScrollPosition(position, withAnimation);
 739 }
 740
 741 float
 742 _ScrollPanel::GetScrollPosition(void) const
 743 {
 744         ClearLastResult();
 745
 746         return __pScrollPanelPresenter->GetScrollPosition();
 747 }
 748
 749 float
 750 _ScrollPanel::GetVerticalScrollPosition(void) const
 751 {
 752         ClearLastResult();
 753
 754         return __pScrollPanelPresenter->GetVerticalScrollPosition();
 755 }
 756
 757 void
 758 _ScrollPanel::SetVerticalScrollPosition(float position)
 759 {
 760         ClearLastResult();
 761
 762         __pScrollPanelPresenter->SetVerticalScrollPosition(position);
 763 }
 764
 765 float
 766 _ScrollPanel::GetHorizontalScrollPosition(void) const
 767 {
 768         ClearLastResult();
 769
 770         return __pScrollPanelPresenter->GetHorizontalScrollPosition();
 771 }
 772
 773 void
 774 _ScrollPanel::SetHorizontalScrollPosition(float position)
 775 {
 776         ClearLastResult();
 777
 778         __pScrollPanelPresenter->SetHorizontalScrollPosition(position);
 779 }
 780
 781 float
 782 _ScrollPanel::CalculatePagingScrollPosition(float position) const
 783 {
 784         ClearLastResult();
 785
 786         return __pScrollPanelPresenter->CalculatePagingScrollPosition(position);
 787 }
 788
 789 bool
 790 _ScrollPanel::ScrollToControl(const _Control& source, bool recursive)
 791 {
 792         ClearLastResult();
 793
 794         return __pScrollPanelPresenter->ScrollToControl(source, recursive);
 795 }
 796
 797 void
 798 _ScrollPanel::ScrollToTop(void) const
 799 {
 800         ClearLastResult();
 801
 802         __pScrollPanelPresenter->ScrollToTop();
 803 }
 804
 805 void
 806 _ScrollPanel::ScrollToBottom(void) const
 807 {
 808         ClearLastResult();
 809
 810         __pScrollPanelPresenter->ScrollToBottom();
 811 }
 812
 813 void
 814 _ScrollPanel::ScrollToLeft(void) const
 815 {
 816         ClearLastResult();
 817
 818         __pScrollPanelPresenter->ScrollToLeft();
 819 }
 820
 821 void
 822 _ScrollPanel::ScrollToRight(void) const
 823 {
 824         ClearLastResult();
 825
 826         __pScrollPanelPresenter->ScrollToRight();
 827 }
 828
 829 void
 830 _ScrollPanel::AddScrollEventListener(const _IScrollEventListener& listener)
 831 {
 832         ClearLastResult();
 833         result r = E_SUCCESS;
 834
 835         if (__pScrollEvent == null)
 836         {
 837                 // Create scroll event
 838                 __pScrollEvent = new (std::nothrow) _UiScrollEvent;
 839                 SysTryReturnVoidResult(NID_UI_CTRL, __pScrollEvent != null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 840
 841                 r = __pScrollEvent->Construct(*this);
 842                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 843         }
 844
 845         r = __pScrollEvent->AddListener((const Tizen::Base::Runtime::IEventListener &)listener);
 846         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 847 }
 848
 849 void
 850 _ScrollPanel::RemoveScrollEventListener(const _IScrollEventListener& listener)
 851 {
 852         ClearLastResult();
 853         SysTryReturnVoidResult(NID_UI_CTRL, __pScrollEvent != null, E_SYSTEM, "[%s] __pScrollEvent is invalid pointer.", GetErrorMessage(E_SYSTEM));
 854
 855         result r = __pScrollEvent->RemoveListener((const Tizen::Base::Runtime::IEventListener &)listener);
 856         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 857 }
 858
 859 void
 860 _ScrollPanel::SetScrollPanelEvent(const _ScrollPanelEvent* pScrollPanelEvent)
 861 {
 862         ClearLastResult();
 863
 864         __pCoreScrollPanelEvent = const_cast<_ScrollPanelEvent*>(pScrollPanelEvent);
 865 }
 866
 867 _ScrollPanelEvent*
 868 _ScrollPanel::GetScrollPanelEvent(void) const
 869 {
 870         ClearLastResult();
 871
 872         return __pCoreScrollPanelEvent;
 873 }
 874
 875 const _Control*
 876 _ScrollPanel::GetControlKeypadBinding(void) const
 877 {
 878         ClearLastResult();
 879
 880         return __pKeyPadBindingControl;
 881 }
 882
 883 void
 884 _ScrollPanel::SetControlKeypadBinding(const _Control* pControl)
 885 {
 886         ClearLastResult();
 887
 888         // pControl can be null
 889         __pKeyPadBindingControl = pControl;
 890 }
 891
 892 ScrollPanelScrollDirection
 893 _ScrollPanel::GetScrollDirection(void) const
 894 {
 895         ClearLastResult();
 896
 897         return __scrollDirection;
 898 }
 899
 900 void
 901 _ScrollPanel::SetScrollDirection(ScrollPanelScrollDirection direction)
 902 {
 903         ClearLastResult();
 904
 905         __scrollDirection = direction;
 906 }
 907
 908 ScrollInputMode
 909 _ScrollPanel::GetScrollInputMode(void) const
 910 {
 911         ClearLastResult();
 912
 913         return __scrollInputMode;
 914 }
 915
 916 void
 917 _ScrollPanel::SetScrollInputMode(ScrollInputMode mode)
 918 {
 919         ClearLastResult();
 920
 921         __scrollInputMode = mode;
 922 }
 923
 924 bool
 925 _ScrollPanel::IsScrollBarVisible(void) const
 926 {
 927         ClearLastResult();
 928
 929         return __scrollBarVisible;
 930 }
 931
 932 void
 933 _ScrollPanel::SetScrollBarVisible(bool scrollBarVisible)
 934 {
 935         ClearLastResult();
 936
 937         __scrollBarVisible = scrollBarVisible;
 938 }
 939
 940 _Scroll*
 941 _ScrollPanel::GetScrollBar(void) const
 942 {
 943         ClearLastResult();
 944
 945         ScrollPanelScrollDirection direction = GetScrollDirection();
 946         if (direction == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 947         {
 948                 return GetHorizontalScrollBar();
 949         }
 950         else
 951         {
 952                 return GetVerticalScrollBar();
 953         }
 954 }
 955 void
 956 _ScrollPanel::SetScrollBar(const _Scroll* pScrollBar)
 957 {
 958         ClearLastResult();
 959
 960         ScrollPanelScrollDirection direction = GetScrollDirection();
 961         if (direction == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 962         {
 963                 SetHorizontalScrollBar(pScrollBar);
 964         }
 965         else
 966         {
 967                 SetVerticalScrollBar(pScrollBar);
 968         }
 969 }
 970
 971 _Scroll*
 972 _ScrollPanel::GetVerticalScrollBar(void) const
 973 {
 974         ClearLastResult();
 975
 976         return __pVerticalScrollBar;
 977 }
 978
 979 void
 980 _ScrollPanel::SetVerticalScrollBar(const _Scroll* pVerticalScrollBar)
 981 {
 982         ClearLastResult();
 983
 984         __pVerticalScrollBar = const_cast<_Scroll*>(pVerticalScrollBar);
 985 }
 986
 987 _Scroll*
 988 _ScrollPanel::GetHorizontalScrollBar(void) const
 989 {
 990         ClearLastResult();
 991
 992         return __pHorizontalScrollBar;
 993 }
 994
 995 void
 996 _ScrollPanel::SetHorizontalScrollBar(const _Scroll* pHorizontalScrollBar)
 997 {
 998         ClearLastResult();
 999
1000         __pHorizontalScrollBar = const_cast<_Scroll*>(pHorizontalScrollBar);
1001 }
1002
1003 bool
1004 _ScrollPanel::IsFixingClientBoundsEnabled(void) const
1005 {
1006         return __fixingClientBoundsEnable;
1007 }
1008
1009 void
1010 _ScrollPanel::SetFixingClientBoundsEnabled(bool enable)
1011 {
1012         __fixingClientBoundsEnable = enable;
1013 }
1014
1015 result
1016 _ScrollPanel::FireOnScrollEndEvent(ScrollEndEvent scrollEndEventType)
1017 {
1018         ClearLastResult();
1019
1020         if (__pScrollEvent == null)
1021         {
1022                 return E_SUCCESS;
1023         }
1024
1025         _UiScrollEventArg* pEventArg = _UiScrollEventArg::GetScrollEventArgN(*this, scrollEndEventType);
1026         result r = GetLastResult();
1027         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1028
1029         __pScrollEvent->Fire(*pEventArg);
1030
1031         return E_SUCCESS;
1032 CATCH:
1033         delete pEventArg;
1034
1035         return E_SUCCESS;
1036 }
1037
1038 result
1039 _ScrollPanel::FireOnScrollPositionChangedEvent(void)
1040 {
1041         ClearLastResult();
1042
1043         return FireOnScrollPositionChangedEvent(__pScrollPanelPresenter->GetScrollPosition());
1044 }
1045
1046 result
1047 _ScrollPanel::FireOnScrollPositionChangedEvent(float scrollPosition)
1048 {
1049         ClearLastResult();
1050
1051         if (__pScrollEvent == null)
1052         {
1053                 return E_SUCCESS;
1054         }
1055
1056         _UiScrollEventArg* pEventArg = _UiScrollEventArg::GetScrollEventArgN(*this, scrollPosition);
1057         result r = GetLastResult();
1058         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1059
1060         __pScrollEvent->Fire(*pEventArg);
1061
1062         return E_SUCCESS;
1063 CATCH:
1064         delete pEventArg;
1065
1066         return E_SUCCESS;
1067 }
1068
1069 result
1070 _ScrollPanel::FireOnScrollStoppedEvent(void)
1071 {
1072         ClearLastResult();
1073
1074         if (__pScrollEvent == null)
1075         {
1076                 return E_SUCCESS;
1077         }
1078
1079         _UiScrollEventArg* pEventArg = _UiScrollEventArg::GetScrollEventArgN(*this);
1080         result r = GetLastResult();
1081         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1082
1083         __pScrollEvent->Fire(*pEventArg);
1084
1085         return E_SUCCESS;
1086 CATCH:
1087         delete pEventArg;
1088
1089         return E_SUCCESS;
1090 }
1091
1092 VisualElementValueAnimation*
1093 _ScrollPanel::GetScrollingAnimation(void) const
1094 {
1095         ClearLastResult();
1096
1097         return __pScrollingAnimation;
1098 }
1099
1100 result
1101 _ScrollPanel::FireScrollPanelEvent(const _Control& source, CoreScrollPanelStatus scrollPanelStatus)
1102 {
1103         ClearLastResult();
1104
1105         if (GetControlKeypadBinding() != &source)
1106         {
1107                 if (__pCoreScrollPanelEvent != null)
1108                 {
1109                         Tizen::Base::Runtime::IEventArg* pEventArg = _ScrollPanelEvent::CreateScrollPanelEventArgN(scrollPanelStatus);
1110                         result r = GetLastResult();
1111                         SysTryReturn(NID_UI_CTRL, pEventArg != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
1112
1113                         __pCoreScrollPanelEvent->Fire(*pEventArg);
1114                 }
1115         }
1116
1117         return E_SUCCESS;
1118 }
1119
1120 }}} // Tizen::Ui::Controls
1121