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 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        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(Dimension(0, 0))
  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 Rectangle& 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         Rectangle areaBounds = const_cast<Rectangle&>(rect);
 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)
 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);
 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)
 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);
 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         return pScrollPanel;
 201
 202 CATCH:
 203         if (pHorizontalScrollBar != null && pScrollPanel->IsAncestorOf(*pHorizontalScrollBar))
 204         {
 205                 pScrollPanel->DetachSystemChild(*pHorizontalScrollBar);
 206         }
 207         delete pHorizontalScrollBar;
 208         pScrollPanel->__pHorizontalScrollBar = null;
 209
 210         if (pVerticalScrollBar != null && pScrollPanel->IsAncestorOf(*pVerticalScrollBar))
 211         {
 212                 pScrollPanel->DetachSystemChild(*pVerticalScrollBar);
 213         }
 214         delete pVerticalScrollBar;
 215         pScrollPanel->__pVerticalScrollBar = null;
 216
 217         delete pPresenter;
 218         pScrollPanel->__pScrollPanelPresenter = null;
 219
 220         delete pScrollPanel;
 221
 222         SetLastResult(r);
 223         return null;
 224 }
 225
 226 result
 227 _ScrollPanel::Initialize(const _ScrollPanelPresenter& presenter)
 228 {
 229         ClearLastResult();
 230
 231         result r = _Panel::Initialize(presenter);
 232         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 233
 234         SetScrollPanelPresenter(&presenter);
 235
 236         __pScrollingAnimation = new (std::nothrow) VisualElementValueAnimation;
 237         SysTryReturn(NID_UI_CTRL, __pScrollingAnimation != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 238
 239         __pScrollingAnimation->SetRepeatCount(SCROLL_PANEL_ANIMATION_DEFAULT_REPEAT_COUNT);
 240         __pScrollingAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseOut"));
 241         r = GetLastResult();
 242         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 243
 244         __pScrollingAnimation->SetVisualElementAnimationTickEventListener(this);
 245         r = GetLastResult();
 246         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 247
 248         __pScrollingAnimation->SetVisualElementAnimationStatusEventListener(this);
 249         r = GetLastResult();
 250         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 251
 252         __pGestureFlick = new (std::nothrow) _TouchFlickGestureDetector;
 253         SysTryCatch(NID_UI_CTRL, __pGestureFlick != null, , E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 254         r = GetLastResult();
 255         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 256
 257         AcquireHandle();
 258
 259         r = AddGestureDetector(*__pGestureFlick);
 260         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 261
 262         r = __pGestureFlick->AddGestureListener(*this);
 263         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 264
 265         return r;
 266
 267 CATCH:
 268         delete __pGestureFlick;
 269         __pGestureFlick = null;
 270
 271         delete __pScrollingAnimation;
 272         __pScrollingAnimation = null;
 273
 274         SetLastResult(r);
 275         return r;
 276 }
 277
 278 result
 279 _ScrollPanel::SetScrollPanelPresenter(const _ScrollPanelPresenter* presenter)
 280 {
 281         ClearLastResult();
 282
 283         _Panel::SetPanelPresenter(presenter);
 284         __pScrollPanelPresenter = const_cast <_ScrollPanelPresenter*>(presenter);
 285
 286         return E_SUCCESS;
 287 }
 288
 289 void
 290 _ScrollPanel::OnDraw(void)
 291 {
 292         ClearLastResult();
 293
 294         if (__pScrollPanelPresenter == null)
 295         {
 296                 return;
 297         }
 298
 299         result r = __pScrollPanelPresenter->Draw();
 300         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 301 }
 302
 303 result
 304 _ScrollPanel::OnBoundsChanging(const Tizen::Graphics::Rectangle& bounds)
 305 {
 306         ClearLastResult();
 307
 308         return __pScrollPanelPresenter->OnBoundsChanging(bounds);
 309 }
 310
 311 void
 312 _ScrollPanel::OnBoundsChanged(void)
 313 {
 314         ClearLastResult();
 315
 316         if (__pScrollPanelPresenter == null)
 317         {
 318                 return;
 319         }
 320
 321         __pScrollPanelPresenter->OnBoundsChanged();
 322 }
 323
 324 void
 325 _ScrollPanel::OnChildAttached(const _Control& child)
 326 {
 327         ClearLastResult();
 328
 329         if (__pScrollPanelPresenter == null)
 330         {
 331                 return;
 332         }
 333
 334         __pScrollPanelPresenter->OnChildAttached(child);
 335 }
 336
 337 void
 338 _ScrollPanel::OnChildDetached(const _Control& child)
 339 {
 340         ClearLastResult();
 341
 342         if (__pScrollPanelPresenter == null)
 343         {
 344                 return;
 345         }
 346
 347         __pScrollPanelPresenter->OnChildDetached(child);
 348 }
 349
 350 void
 351 _ScrollPanel::OnChildBoundsChanged(const _Control& child)
 352 {
 353         ClearLastResult();
 354
 355         if (__pScrollPanelPresenter == null)
 356         {
 357                 return;
 358         }
 359
 360         __pScrollPanelPresenter->OnChildBoundsChanged(child);
 361 }
 362
 363 bool
 364 _ScrollPanel::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 365 {
 366         ClearLastResult();
 367
 368         return __pScrollPanelPresenter->OnFlickGestureDetected(gesture);
 369 }
 370
 371 bool
 372 _ScrollPanel::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 373 {
 374         ClearLastResult();
 375
 376         return __pScrollPanelPresenter->OnFlickGestureCanceled(gesture);
 377 }
 378
 379 bool
 380 _ScrollPanel::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 381 {
 382         ClearLastResult();
 383
 384         return __pScrollPanelPresenter->OnAccessibilityFocusMovedNext(control, element);
 385 }
 386
 387 bool
 388 _ScrollPanel::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 389 {
 390         ClearLastResult();
 391
 392         return __pScrollPanelPresenter->OnAccessibilityFocusMovedPrevious(control, element);
 393 }
 394
 395 bool
 396 _ScrollPanel::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 397 {
 398         ClearLastResult();
 399
 400         return __pScrollPanelPresenter->OnAccessibilityReadElement(control, element);
 401 }
 402
 403 bool
 404 _ScrollPanel::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 405 {
 406         ClearLastResult();
 407
 408         return __pScrollPanelPresenter->OnAccessibilityFocusIn(control, element);
 409 }
 410
 411 bool
 412 _ScrollPanel::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 413 {
 414         ClearLastResult();
 415
 416         return __pScrollPanelPresenter->OnAccessibilityFocusOut(control, element);
 417 }
 418
 419 bool
 420 _ScrollPanel::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 421 {
 422         ClearLastResult();
 423
 424         return __pScrollPanelPresenter->OnAccessibilityActionPerformed(control, element);
 425 }
 426 bool
 427 _ScrollPanel::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 428 {
 429         return true;
 430 }
 431 bool
 432 _ScrollPanel::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 433 {
 434         return true;
 435 }
 436 _UiTouchEventDelivery
 437 _ScrollPanel::OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 438 {
 439         ClearLastResult();
 440
 441         return __pScrollPanelPresenter->OnPreviewTouchPressed(source, touchinfo);
 442 }
 443
 444 _UiTouchEventDelivery
 445 _ScrollPanel::OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 446 {
 447         ClearLastResult();
 448
 449         return __pScrollPanelPresenter->OnPreviewTouchMoved(source, touchinfo);
 450 }
 451
 452 _UiTouchEventDelivery
 453 _ScrollPanel::OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 454 {
 455         ClearLastResult();
 456
 457         return __pScrollPanelPresenter->OnPreviewTouchReleased(source, touchinfo);
 458 }
 459
 460 _UiTouchEventDelivery
 461 _ScrollPanel::OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 462 {
 463         ClearLastResult();
 464
 465         return __pScrollPanelPresenter->OnPreviewTouchCanceled(source, touchinfo);
 466 }
 467
 468 bool
 469 _ScrollPanel::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 470 {
 471         ClearLastResult();
 472
 473         return __pScrollPanelPresenter->OnTouchPressed(source, touchinfo);
 474 }
 475
 476 bool
 477 _ScrollPanel::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 478 {
 479         ClearLastResult();
 480
 481         return __pScrollPanelPresenter->OnTouchMoved(source, touchinfo);
 482 }
 483
 484 bool
 485 _ScrollPanel::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 486 {
 487         ClearLastResult();
 488
 489         return __pScrollPanelPresenter->OnTouchReleased(source, touchinfo);
 490 }
 491
 492 bool
 493 _ScrollPanel::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 494 {
 495         ClearLastResult();
 496
 497         return __pScrollPanelPresenter->OnTouchCanceled(source, touchinfo);
 498 }
 499
 500 void
 501 _ScrollPanel::OnTouchMoveHandled(const _Control& control)
 502 {
 503         ClearLastResult();
 504
 505         return __pScrollPanelPresenter->OnTouchMoveHandled(control);
 506 }
 507
 508 void
 509 _ScrollPanel::OnScrollEndReached(_Control& source, ScrollEndEvent type)
 510 {
 511         ClearLastResult();
 512
 513         __pScrollPanelPresenter->OnScrollEndReached(source, type);
 514 }
 515
 516 void
 517 _ScrollPanel::OnScrollPositionChanged(_Control& source, int scrollPos)
 518 {
 519         ClearLastResult();
 520
 521         __pScrollPanelPresenter->OnScrollPositionChanged(source, scrollPos);
 522 }
 523
 524 void
 525 _ScrollPanel::OnVisualElementAnimationStarted(const VisualElementAnimation& animation, const String& keyName, VisualElement& target)
 526 {
 527         ClearLastResult();
 528
 529         if (__pScrollPanelPresenter == null)
 530         {
 531                 return;
 532         }
 533
 534         __pScrollPanelPresenter->OnVisualElementAnimationStarted(animation, keyName, target);
 535 }
 536
 537 void
 538 _ScrollPanel::OnVisualElementAnimationRepeated(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, long currentRepeatCount)
 539 {
 540         ClearLastResult();
 541
 542         if (__pScrollPanelPresenter == null)
 543         {
 544                 return;
 545         }
 546
 547         __pScrollPanelPresenter->OnVisualElementAnimationRepeated(animation, keyName, target, currentRepeatCount);
 548 }
 549
 550 void
 551 _ScrollPanel::OnVisualElementAnimationFinished(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, bool completedNormally)
 552 {
 553         ClearLastResult();
 554
 555         if (__pScrollPanelPresenter == null)
 556         {
 557                 return;
 558         }
 559
 560         __pScrollPanelPresenter->OnVisualElementAnimationFinished(animation, keyName, target, completedNormally);
 561 }
 562
 563 void
 564 _ScrollPanel::OnTickOccurred(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, const Variant& currentValue)
 565 {
 566         ClearLastResult();
 567
 568         __pScrollPanelPresenter->OnTickOccurred(animation, keyName, target, currentValue);
 569 }
 570
 571 bool
 572 _ScrollPanel::IsScrollAreaAutoResizingEnabled(void) const
 573 {
 574         ClearLastResult();
 575
 576         return __autoResizingEnable;
 577 }
 578
 579 void
 580 _ScrollPanel::SetScrollAreaAutoResizingEnabled(bool autoResizingEnable)
 581 {
 582         ClearLastResult();
 583
 584         __autoResizingEnable = autoResizingEnable;
 585 }
 586
 587 Rectangle
 588 _ScrollPanel::GetScrollAreaBounds(void) const
 589 {
 590         ClearLastResult();
 591
 592         return __pScrollPanelPresenter->GetScrollAreaBounds();
 593 }
 594
 595 result
 596 _ScrollPanel::SetClientAreaHeight(int height)
 597 {
 598         ClearLastResult();
 599
 600         return __pScrollPanelPresenter->SetClientAreaHeight(height);
 601 }
 602
 603 result
 604 _ScrollPanel::SetClientAreaWidth(int width)
 605 {
 606         ClearLastResult();
 607
 608         return __pScrollPanelPresenter->SetClientAreaWidth(width);
 609 }
 610
 611 result
 612 _ScrollPanel::SetScrollAreaBounds(Rectangle& bounds)
 613 {
 614         ClearLastResult();
 615
 616         return __pScrollPanelPresenter->SetScrollAreaBounds(bounds);
 617 }
 618
 619 bool
 620 _ScrollPanel::IsPageScrollEnabled(void) const
 621 {
 622         ClearLastResult();
 623
 624         return __pageScrollEnabled;
 625 }
 626
 627 void
 628 _ScrollPanel::SetPageScrollEnabled(bool enable)
 629 {
 630         ClearLastResult();
 631
 632         __pageScrollEnabled = enable;
 633 }
 634
 635 Dimension
 636 _ScrollPanel::GetPageScrollAlignSize(void) const
 637 {
 638         ClearLastResult();
 639
 640         return __pageScrollAlignSize;
 641 }
 642
 643 void
 644 _ScrollPanel::SetPageScrollAlignSize(Dimension size)
 645 {
 646         ClearLastResult();
 647
 648         __pageScrollAlignSize = size;
 649 }
 650
 651 bool
 652 _ScrollPanel::IsPageScrollFlickMoveLimitedOnePage(void) const
 653 {
 654         return __pageScrollMoveOnlyOnePageOnFlick;
 655 }
 656
 657 void
 658 _ScrollPanel::SetScrollPosition(int position, bool withAnimation)
 659 {
 660         ClearLastResult();
 661
 662         __pScrollPanelPresenter->SetScrollPosition(position, withAnimation);
 663 }
 664
 665 int
 666 _ScrollPanel::GetScrollPosition(void) const
 667 {
 668         ClearLastResult();
 669
 670         return __pScrollPanelPresenter->GetScrollPosition();
 671 }
 672
 673 int
 674 _ScrollPanel::GetVerticalScrollPosition(void) const
 675 {
 676         ClearLastResult();
 677
 678         return __pScrollPanelPresenter->GetVerticalScrollPosition();
 679 }
 680
 681 void
 682 _ScrollPanel::SetVerticalScrollPosition(int position)
 683 {
 684         ClearLastResult();
 685
 686         __pScrollPanelPresenter->SetVerticalScrollPosition(position);
 687 }
 688
 689 int
 690 _ScrollPanel::GetHorizontalScrollPosition(void) const
 691 {
 692         ClearLastResult();
 693
 694         return __pScrollPanelPresenter->GetHorizontalScrollPosition();
 695 }
 696
 697 void
 698 _ScrollPanel::SetHorizontalScrollPosition(int position)
 699 {
 700         ClearLastResult();
 701
 702         __pScrollPanelPresenter->SetHorizontalScrollPosition(position);
 703 }
 704
 705 bool
 706 _ScrollPanel::ScrollToControl(const _Control& source)
 707 {
 708         ClearLastResult();
 709
 710         return __pScrollPanelPresenter->ScrollToControl(source);
 711 }
 712
 713 void
 714 _ScrollPanel::ScrollToTop(void) const
 715 {
 716         ClearLastResult();
 717
 718         __pScrollPanelPresenter->ScrollToTop();
 719 }
 720
 721 void
 722 _ScrollPanel::ScrollToBottom(void) const
 723 {
 724         ClearLastResult();
 725
 726         __pScrollPanelPresenter->ScrollToBottom();
 727 }
 728
 729 void
 730 _ScrollPanel::ScrollToLeft(void) const
 731 {
 732         ClearLastResult();
 733
 734         __pScrollPanelPresenter->ScrollToLeft();
 735 }
 736
 737 void
 738 _ScrollPanel::ScrollToRight(void) const
 739 {
 740         ClearLastResult();
 741
 742         __pScrollPanelPresenter->ScrollToRight();
 743 }
 744
 745 void
 746 _ScrollPanel::AddScrollEventListener(const _IScrollEventListener& listener)
 747 {
 748         ClearLastResult();
 749         result r = E_SUCCESS;
 750
 751         if (__pScrollEvent == null)
 752         {
 753                 // Create scroll event
 754                 __pScrollEvent = new (std::nothrow) _UiScrollEvent;
 755                 SysTryReturnVoidResult(NID_UI_CTRL, __pScrollEvent != null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 756
 757                 r = __pScrollEvent->Construct(*this);
 758                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 759         }
 760
 761         r = __pScrollEvent->AddListener((const Tizen::Base::Runtime::IEventListener &)listener);
 762         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 763 }
 764
 765 void
 766 _ScrollPanel::RemoveScrollEventListener(const _IScrollEventListener& listener)
 767 {
 768         ClearLastResult();
 769         SysTryReturnVoidResult(NID_UI_CTRL, __pScrollEvent != null, E_SYSTEM, "[%s] __pScrollEvent is invalid pointer.", GetErrorMessage(E_SYSTEM));
 770
 771         result r = __pScrollEvent->RemoveListener((const Tizen::Base::Runtime::IEventListener &)listener);
 772         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 773 }
 774
 775 void
 776 _ScrollPanel::SetScrollPanelEvent(const _ScrollPanelEvent* pScrollPanelEvent)
 777 {
 778         ClearLastResult();
 779
 780         __pCoreScrollPanelEvent = const_cast<_ScrollPanelEvent*>(pScrollPanelEvent);
 781 }
 782
 783 _ScrollPanelEvent*
 784 _ScrollPanel::GetScrollPanelEvent(void) const
 785 {
 786         ClearLastResult();
 787
 788         return __pCoreScrollPanelEvent;
 789 }
 790
 791 const _Control*
 792 _ScrollPanel::GetControlKeypadBinding(void) const
 793 {
 794         ClearLastResult();
 795
 796         return __pKeyPadBindingControl;
 797 }
 798
 799 void
 800 _ScrollPanel::SetControlKeypadBinding(const _Control* pControl)
 801 {
 802         ClearLastResult();
 803
 804         // pControl can be null
 805         __pKeyPadBindingControl = pControl;
 806 }
 807
 808 ScrollPanelScrollDirection
 809 _ScrollPanel::GetScrollDirection(void) const
 810 {
 811         ClearLastResult();
 812
 813         return __scrollDirection;
 814 }
 815
 816 void
 817 _ScrollPanel::SetScrollDirection(ScrollPanelScrollDirection direction)
 818 {
 819         ClearLastResult();
 820
 821         __scrollDirection = direction;
 822 }
 823
 824 ScrollInputMode
 825 _ScrollPanel::GetScrollInputMode(void) const
 826 {
 827         ClearLastResult();
 828
 829         return __scrollInputMode;
 830 }
 831
 832 void
 833 _ScrollPanel::SetScrollInputMode(ScrollInputMode mode)
 834 {
 835         ClearLastResult();
 836
 837         __scrollInputMode = mode;
 838 }
 839
 840 bool
 841 _ScrollPanel::IsScrollBarVisible(void) const
 842 {
 843         ClearLastResult();
 844
 845         return __scrollBarVisible;
 846 }
 847
 848 void
 849 _ScrollPanel::SetScrollBarVisible(bool scrollBarVisible)
 850 {
 851         ClearLastResult();
 852
 853         __scrollBarVisible = scrollBarVisible;
 854 }
 855
 856 _Scroll*
 857 _ScrollPanel::GetScrollBar(void) const
 858 {
 859         ClearLastResult();
 860
 861         ScrollPanelScrollDirection direction = GetScrollDirection();
 862         if (direction == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 863         {
 864                 return GetHorizontalScrollBar();
 865         }
 866         else
 867         {
 868                 return GetVerticalScrollBar();
 869         }
 870 }
 871 void
 872 _ScrollPanel::SetScrollBar(const _Scroll* pScrollBar)
 873 {
 874         ClearLastResult();
 875
 876         ScrollPanelScrollDirection direction = GetScrollDirection();
 877         if (direction == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 878         {
 879                 SetHorizontalScrollBar(pScrollBar);
 880         }
 881         else
 882         {
 883                 SetVerticalScrollBar(pScrollBar);
 884         }
 885 }
 886
 887 _Scroll*
 888 _ScrollPanel::GetVerticalScrollBar(void) const
 889 {
 890         ClearLastResult();
 891
 892         return __pVerticalScrollBar;
 893 }
 894
 895 void
 896 _ScrollPanel::SetVerticalScrollBar(const _Scroll* pVerticalScrollBar)
 897 {
 898         ClearLastResult();
 899
 900         __pVerticalScrollBar = const_cast<_Scroll*>(pVerticalScrollBar);
 901 }
 902
 903 _Scroll*
 904 _ScrollPanel::GetHorizontalScrollBar(void) const
 905 {
 906         ClearLastResult();
 907
 908         return __pHorizontalScrollBar;
 909 }
 910
 911 void
 912 _ScrollPanel::SetHorizontalScrollBar(const _Scroll* pHorizontalScrollBar)
 913 {
 914         ClearLastResult();
 915
 916         __pHorizontalScrollBar = const_cast<_Scroll*>(pHorizontalScrollBar);
 917 }
 918
 919 bool
 920 _ScrollPanel::IsFixingClientBoundsEnable(void) const
 921 {
 922         return __fixingClientBoundsEnable;
 923 }
 924
 925 void
 926 _ScrollPanel::SetFixingClientBoundsEnable(bool enable)
 927 {
 928         __fixingClientBoundsEnable = enable;
 929 }
 930
 931 result
 932 _ScrollPanel::FireOnScrollEndEvent(ScrollEndEvent scrollEndEventType)
 933 {
 934         ClearLastResult();
 935
 936         if (__pScrollEvent == null)
 937         {
 938                 return E_SUCCESS;
 939         }
 940
 941         _UiScrollEventArg* pEventArg = _UiScrollEventArg::GetScrollEventArgN(*this, scrollEndEventType);
 942         result r = GetLastResult();
 943         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 944
 945         __pScrollEvent->Fire(*pEventArg);
 946
 947         return E_SUCCESS;
 948 CATCH:
 949         delete pEventArg;
 950
 951         return E_SUCCESS;
 952 }
 953
 954 result
 955 _ScrollPanel::FireOnScrollPositionChangedEvent(void)
 956 {
 957         ClearLastResult();
 958
 959         return FireOnScrollPositionChangedEvent(__pScrollPanelPresenter->GetScrollPosition());
 960 }
 961
 962 result
 963 _ScrollPanel::FireOnScrollPositionChangedEvent(int scrollPosition)
 964 {
 965         ClearLastResult();
 966
 967         if (__pScrollEvent == null)
 968         {
 969                 return E_SUCCESS;
 970         }
 971
 972         _UiScrollEventArg* pEventArg = _UiScrollEventArg::GetScrollEventArgN(*this, scrollPosition);
 973         result r = GetLastResult();
 974         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 975
 976         __pScrollEvent->Fire(*pEventArg);
 977
 978         return E_SUCCESS;
 979 CATCH:
 980         delete pEventArg;
 981
 982         return E_SUCCESS;
 983 }
 984
 985 result
 986 _ScrollPanel::FireOnScrollStoppedEvent(void)
 987 {
 988         ClearLastResult();
 989
 990         if (__pScrollEvent == null)
 991         {
 992                 return E_SUCCESS;
 993         }
 994
 995         _UiScrollEventArg* pEventArg = _UiScrollEventArg::GetScrollEventArgN(*this);
 996         result r = GetLastResult();
 997         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 998
 999         __pScrollEvent->Fire(*pEventArg);
1000
1001         return E_SUCCESS;
1002 CATCH:
1003         delete pEventArg;
1004
1005         return E_SUCCESS;
1006 }
1007
1008 VisualElementValueAnimation*
1009 _ScrollPanel::GetScrollingAnimation(void) const
1010 {
1011         ClearLastResult();
1012
1013         return __pScrollingAnimation;
1014 }
1015
1016 result
1017 _ScrollPanel::FireScrollPanelEvent(const _Control& source, CoreScrollPanelStatus scrollPanelStatus)
1018 {
1019         ClearLastResult();
1020
1021         if (GetControlKeypadBinding() != &source)
1022         {
1023                 if (__pCoreScrollPanelEvent != null)
1024                 {
1025                         Tizen::Base::Runtime::IEventArg* pEventArg = _ScrollPanelEvent::CreateScrollPanelEventArgN(scrollPanelStatus);
1026                         result r = GetLastResult();
1027                         SysTryReturn(NID_UI_CTRL, pEventArg != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
1028
1029                         __pCoreScrollPanelEvent->Fire(*pEventArg);
1030                 }
1031         }
1032
1033         return E_SUCCESS;
1034 }
1035
1036 }}} // Tizen::Ui::Controls
1037