src/ui/controls/FUiCtrl_ScrollPanelPresenter.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_ScrollPanelPresenter.cpp
  20  * @brief       This is the implementation file for the %_ScrollPanelPresenter class.
  21  *
  22  */
  23
  24 #include <FBaseCol.h>
  25 #include <FBaseErrorDefine.h>
  26 #include <FBaseRtTimer.h>
  27 #include <FBaseUtilMath.h>
  28 #include <FBaseSysLog.h>
  29 #include <FGrpFloatMatrix4.h>
  30 #include <FUiAnimVisualElementValueAnimation.h>
  31 #include "FUi_ResourceManager.h"
  32 #include "FUi_UiTouchEvent.h"
  33 #include "FUi_IAccessibilityListener.h"
  34 #include "FUi_AccessibilityContainer.h"
  35 #include "FUi_AccessibilityElement.h"
  36 #include "FUiAnim_VisualElement.h"
  37 #include "FUiCtrl_Scroll.h"
  38 #include "FUiCtrl_ScrollPanel.h"
  39 #include "FUiCtrl_ScrollPanelImpl.h"
  40 #include "FUiCtrl_ScrollPanelPresenter.h"
  41 #include "FUiCtrl_ScrollPanelModel.h"
  42
  43 using namespace Tizen::Base;
  44 using namespace Tizen::Graphics;
  45 using namespace Tizen::Ui::Animations;
  46
  47 namespace
  48 {
  49 const int SCROLL_PANEL_SCROLLING_ANIMATION_DURATION = 1000;
  50 const int SCROLL_PANEL_OVERSCROLLING_MAX_DISTANCCE = 100;
  51
  52 const int SCROLL_PANEL_FLICK_IN_PIXEL_UNIT = 1000;
  53 const int SCROLL_PANEL_FLICK_WEIGHT_VELOCITY = 1;
  54 const int SCROLL_PANEL_FLICK_WEIGHT_DISTANCE = 5;
  55 const int SCROLL_PANEL_FLICK_ALPHA_PER_PIXEL = 3;
  56
  57 const int SCROLL_PANEL_SCROLL_BAR_LOAD_EFFECT_TIMER_DURATION = 1000;
  58 const int SCROLL_PANEL_FLICK_SCROLL_EFFECT_TIMER_DURATION = 2000;
  59
  60 const String SCROLLING_ANIMATION_NAME(L"SCROLL_PANEL_SCROLLING_ANIMATION");
  61 }
  62
  63 namespace Tizen { namespace Ui { namespace Controls
  64 {
  65
  66 _ScrollPanelPresenter::_ScrollPanelPresenter(void)
  67         : __pScrollPanel(null)
  68         , __pScrollPanelModel(null)
  69         , __pPressedControl(null)
  70         , __subControlMoved(false)
  71         , __touchPressed(false)
  72         , __scrollOccured(false)
  73         , __scrollAnimationRunning(false)
  74         , __flickRunning(false)
  75         , __pFlickScrollEffectTimer(null)
  76         , __flickDirection(_FLICK_DIRECTION_NONE)
  77         , __flickCount(0)
  78         , __pScrollBarLoadEffectTimer(null)
  79         , __scrollBarFirstLoaded(true)
  80         , __bouncing(false)
  81         , __firstTouchMove(true)
  82         , __firstScrollMoveDirection(SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL)
  83 {
  84         // nothing
  85 }
  86
  87 _ScrollPanelPresenter::~_ScrollPanelPresenter(void)
  88 {
  89         delete __pScrollBarLoadEffectTimer;
  90         __pScrollBarLoadEffectTimer = null;
  91
  92         delete __pFlickScrollEffectTimer;
  93         __pFlickScrollEffectTimer = null;
  94
  95         delete __pScrollPanelModel;
  96         __pScrollPanelModel = null;
  97 }
  98
  99 result
 100 _ScrollPanelPresenter::Initialize(_ScrollPanel& scrollPanel)
 101 {
 102         result r = _PanelPresenter::Initialize(scrollPanel);
 103         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 104
 105         __pScrollPanel = &scrollPanel;
 106
 107         // create model
 108         _ScrollPanelModel* pModel = new (std::nothrow) _ScrollPanelModel;
 109         SysTryReturn(NID_UI_CTRL, pModel != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] The memory is insufficient", GetErrorMessage(E_OUT_OF_MEMORY));
 110
 111         __pScrollPanelModel = pModel;
 112
 113         return E_SUCCESS;
 114 }
 115
 116 result
 117 _ScrollPanelPresenter::Draw(void)
 118 {
 119         if (__pScrollPanel->GetBackgroundBitmap() == null)
 120         {
 121                 return E_SUCCESS;
 122         }
 123
 124         Canvas* pCanvas = __pScrollPanel->GetVisualElement()->GetCanvasN();
 125         result r = GetLastResult();
 126         SysTryReturn(NID_UI_CTRL, pCanvas != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 127         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 128
 129         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 130         r = GetLastResult();
 131         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 132
 133         r = pCanvas->Clear();
 134         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 135
 136         DrawBackgrounBitmap(pCanvas);
 137         r = GetLastResult();
 138         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 139
 140         // fall throw
 141 CATCH:
 142         delete pCanvas;
 143
 144         return r;
 145 }
 146
 147 result
 148 _ScrollPanelPresenter::OnBoundsChanging(const Tizen::Graphics::Rectangle& bounds)
 149 {
 150         ScrollPanelScrollDirection scrollDirection = __pScrollPanel->GetScrollDirection();
 151         Rectangle scrollArea = GetScrollAreaBounds();
 152         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 153         {
 154                 if (scrollArea.width < bounds.width)
 155                 {
 156                         scrollArea.width = bounds.width;
 157                 }
 158         }
 159         else
 160         {
 161                 if (scrollArea.height < bounds.height)
 162                 {
 163                         scrollArea.height = bounds.height;
 164                 }
 165         }
 166         int scrollPosition = GetScrollPosition();
 167         int fixedScrollPosition = FixScrollPositionIntoScrollAreaBounds(scrollPosition, bounds, scrollArea);
 168         if (scrollPosition != fixedScrollPosition)
 169         {
 170                 ScrollTo(fixedScrollPosition, false);
 171                 result r = GetLastResult();
 172                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 173         }
 174
 175         return E_SUCCESS;
 176 }
 177
 178 void
 179 _ScrollPanelPresenter::OnBoundsChanged(void)
 180 {
 181         AdjustModel();
 182 }
 183
 184 void
 185 _ScrollPanelPresenter::OnChildAttached(const _Control& child)
 186 {
 187         if (&child != __pScrollPanel->GetVerticalScrollBar()
 188                         && &child != __pScrollPanel->GetHorizontalScrollBar())
 189         {
 190                 if (__pScrollPanel->IsScrollAreaAutoResizingEnabled())
 191                 {
 192                         UpdateLayout();
 193                 }
 194
 195                 AdjustModel();
 196
 197                 _AccessibilityContainer* pChildAccessibilityContainer = (const_cast<_Control&>(child)).GetAccessibilityContainer();
 198                 pChildAccessibilityContainer->AddListener(*__pScrollPanel);
 199         }
 200
 201 }
 202
 203 void
 204 _ScrollPanelPresenter::OnChildDetached(const _Control& child)
 205 {
 206         if (&child != __pScrollPanel->GetVerticalScrollBar()
 207                         && &child != __pScrollPanel->GetHorizontalScrollBar())
 208         {
 209                 if (__pScrollPanel->IsScrollAreaAutoResizingEnabled())
 210                 {
 211                         UpdateLayout();
 212                 }
 213
 214                 AdjustModel();
 215
 216                 _AccessibilityContainer* pChildAccessibilityContainer = (const_cast<_Control&>(child)).GetAccessibilityContainer();
 217                 pChildAccessibilityContainer->RemoveListener(*__pScrollPanel);
 218         }
 219
 220 }
 221
 222 void
 223 _ScrollPanelPresenter::OnChildBoundsChanged(const _Control& child)
 224 {
 225         if (&child != __pScrollPanel->GetVerticalScrollBar()
 226                         && &child != __pScrollPanel->GetHorizontalScrollBar())
 227         {
 228                 AdjustModel();
 229         }
 230 }
 231
 232 void
 233 _ScrollPanelPresenter::SetScrollPosition(int position, bool withAnimation)
 234 {
 235         // change scroll position
 236         if (withAnimation)
 237         {
 238                 FadeInScrollBar();
 239                 result r = GetLastResult();
 240                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 241         }
 242
 243         position = FixScrollPositionIntoScrollAreaBounds(position);
 244         ScrollTo(position, withAnimation);
 245         result r = GetLastResult();
 246         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 247 }
 248
 249 int
 250 _ScrollPanelPresenter::GetScrollPosition(void) const
 251 {
 252         int scrollPosition = GetScrollPositionInternal();
 253         return FixScrollPositionIntoScrollAreaBounds(scrollPosition);
 254 }
 255
 256 int
 257 _ScrollPanelPresenter::GetVerticalScrollPosition(void) const
 258 {
 259         int scrollPosition = GetVerticalScrollPositionInternal();
 260         return FixScrollPositionIntoScrollAreaBounds(scrollPosition);
 261 }
 262
 263 void
 264 _ScrollPanelPresenter::SetVerticalScrollPosition(int position)
 265 {
 266         SetScrollPosition(position, true);
 267 }
 268
 269 int
 270 _ScrollPanelPresenter::GetHorizontalScrollPosition(void) const
 271 {
 272         int scrollPosition = GetHorizontalScrollPositionInternal();
 273         return FixScrollPositionIntoScrollAreaBounds(scrollPosition);
 274 }
 275
 276 void
 277 _ScrollPanelPresenter::SetHorizontalScrollPosition(int position)
 278 {
 279         SetScrollPosition(position, true);
 280 }
 281
 282 int
 283 _ScrollPanelPresenter::GetScrollPositionInternal(void) const
 284 {
 285         ScrollPanelScrollDirection scrollDirection = __pScrollPanel->GetScrollDirection();
 286
 287         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 288         {
 289                 return GetHorizontalScrollPositionInternal();
 290         }
 291         else
 292         {
 293                 return GetVerticalScrollPositionInternal();
 294         }
 295 }
 296
 297 void
 298 _ScrollPanelPresenter::SetScrollPositionInternal(int position)
 299 {
 300         ScrollPanelScrollDirection scrollDirection = __pScrollPanel->GetScrollDirection();
 301         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 302         {
 303                 SetHorizontalScrollPositionInternal(position);
 304         }
 305         else
 306         {
 307                 SetVerticalScrollPositionInternal(position);
 308         }
 309 }
 310
 311 int
 312 _ScrollPanelPresenter::GetVerticalScrollPositionInternal(void) const
 313 {
 314         return __pScrollPanelModel->GetCurrentVerticalScrollPosition();
 315 }
 316
 317 void
 318 _ScrollPanelPresenter::SetVerticalScrollPositionInternal(int position)
 319 {
 320         __pScrollPanelModel->SetCurrentVerticalScrollPosition(position);
 321 }
 322
 323 int
 324 _ScrollPanelPresenter::GetHorizontalScrollPositionInternal(void) const
 325 {
 326         return __pScrollPanelModel->GetCurrentHorizontalScrollPosition();
 327 }
 328
 329 void
 330 _ScrollPanelPresenter::SetHorizontalScrollPositionInternal(int position)
 331 {
 332         __pScrollPanelModel->SetCurrentHorizontalScrollPosition(position);
 333 }
 334
 335 void
 336 _ScrollPanelPresenter::StopScrollingAnimation(void)
 337 {
 338         __scrollAnimationRunning = false;
 339         __pScrollPanel->GetVisualElement()->RemoveAnimation(SCROLLING_ANIMATION_NAME);
 340 }
 341
 342 int
 343 _ScrollPanelPresenter::FixScrollPositionIntoScrollAreaBounds(int position) const
 344 {
 345         return FixScrollPositionIntoScrollAreaBounds(position, __pScrollPanel->GetBounds(), GetScrollAreaBounds());
 346 }
 347
 348 int
 349 _ScrollPanelPresenter::FixScrollPositionIntoScrollAreaBounds(int position, Rectangle bounds, Rectangle scrollArea) const
 350 {
 351         int minScrollPos = 0;
 352         int maxScrollPos = 0;
 353         if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 354         {
 355                 minScrollPos = scrollArea.x;
 356                 maxScrollPos = scrollArea.x + scrollArea.width - bounds.width;
 357         }
 358         else
 359         {
 360                 minScrollPos = scrollArea.y;
 361                 maxScrollPos = scrollArea.y + scrollArea.height - bounds.height;
 362         }
 363         position = position < minScrollPos ? minScrollPos : position;
 364         position = position > maxScrollPos ? maxScrollPos : position;
 365
 366         return position;
 367 }
 368
 369 void
 370 _ScrollPanelPresenter::ScrollToTop(void)
 371 {
 372         SetVerticalScrollPosition(GetScrollAreaBounds().y);
 373 }
 374
 375 void
 376 _ScrollPanelPresenter::ScrollToBottom(void)
 377 {
 378         SetVerticalScrollPosition(GetScrollAreaBounds().height - __pScrollPanel->GetBounds().height);
 379 }
 380
 381 void
 382 _ScrollPanelPresenter::ScrollToLeft(void)
 383 {
 384         SetHorizontalScrollPosition(GetScrollAreaBounds().x);
 385 }
 386
 387 void
 388 _ScrollPanelPresenter::ScrollToRight(void)
 389 {
 390         SetHorizontalScrollPosition(GetScrollAreaBounds().width - __pScrollPanel->GetBounds().width);
 391 }
 392
 393 result
 394 _ScrollPanelPresenter::RunPreviewTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
 395 {
 396         result r = E_SUCCESS;
 397
 398         // stop flick, stop scroll animation
 399         if (__flickRunning || __scrollAnimationRunning)
 400         {
 401                 StopScrollingAnimation();
 402         }
 403
 404         __currentMovedPosition = touchInfo.GetCurrentPosition();
 405         __previousTouchedPosition = __currentMovedPosition;
 406         __pPressedControl = &(const_cast<_Control&>(source));
 407         __subControlMoved = false;
 408         __touchPressed = true;
 409         __firstTouchMove = true;
 410
 411         return r;
 412 }
 413
 414 result
 415 _ScrollPanelPresenter::RunPreviewTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
 416 {
 417         if (__pPressedControl == &source && __touchPressed)
 418         {
 419                 __previousTouchedPosition = __currentMovedPosition;
 420                 __currentMovedPosition = touchInfo.GetCurrentPosition();
 421
 422                 if (__pScrollPanel != &source)
 423                 {
 424                         __subControlMoved = true;
 425                 }
 426
 427                 if (__firstTouchMove)
 428                 {
 429                         ScrollPanelScrollDirection scrollDirection = __pScrollPanel->GetScrollDirection();
 430                         int scrollDistanceX = __previousTouchedPosition.x - __currentMovedPosition.x;
 431                         int scrollDistanceY = __previousTouchedPosition.y - __currentMovedPosition.y;
 432
 433                         if (abs(scrollDistanceY) < abs(scrollDistanceX))
 434                         {
 435                                 __firstScrollMoveDirection = SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL;
 436                         }
 437                         else if (abs(scrollDistanceY) > abs(scrollDistanceX))
 438                         {
 439                                 __firstScrollMoveDirection = SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL;
 440                         }
 441                         else
 442                         {
 443                                 __firstScrollMoveDirection = scrollDirection;
 444                         }
 445
 446                         __firstTouchMove = false;
 447                 }
 448         }
 449
 450         return E_SUCCESS;
 451 }
 452
 453 result
 454 _ScrollPanelPresenter::RunPreviewTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 455 {
 456         result r = E_SUCCESS;
 457
 458         if (__pPressedControl != &source)
 459         {
 460                 return r;
 461         }
 462
 463         __touchPressed = false;
 464         __firstTouchMove = true;
 465
 466         if (__pScrollPanel->IsPageScrollEnabled() && !__flickRunning)
 467         {
 468                 int currentPosition = 0;
 469                 int maxPosition = 0;
 470                 int pageSize = 0;
 471
 472                 if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 473                 {
 474                         pageSize = __pScrollPanel->GetPageScrollAlignSize().width;
 475                         maxPosition = GetScrollAreaBounds().width - pageSize;
 476                         currentPosition = GetHorizontalScrollPosition();
 477                 }
 478                 else
 479                 {
 480                         pageSize = __pScrollPanel->GetPageScrollAlignSize().height;
 481                         maxPosition = GetScrollAreaBounds().height - pageSize;
 482                         currentPosition = GetVerticalScrollPosition();
 483                 }
 484
 485                 int targetPosition = 0;
 486                 int pageGap = currentPosition % pageSize;
 487                 int lowerPageIndex = currentPosition / pageSize;
 488                 int currentPageMin = pageSize * lowerPageIndex;
 489                 int currentPageMax = currentPageMin + pageSize;
 490                 currentPageMin = currentPageMax > maxPosition ? (maxPosition / pageSize) * pageSize : currentPageMin;
 491                 currentPageMax = currentPageMax > maxPosition ? maxPosition : currentPageMax;
 492
 493                 if (pageGap <= currentPageMax - currentPageMin - pageGap)
 494                 {
 495                         targetPosition = currentPageMin;
 496                 }
 497                 else
 498                 {
 499                         targetPosition = currentPageMax;
 500                 }
 501
 502                 if (targetPosition != currentPosition)
 503                 {
 504                         SetScrollPosition(targetPosition, true);
 505                         r = GetLastResult();
 506                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 507                 }
 508         }
 509
 510         // scrollpanel child control touch released
 511         if (__pScrollPanel != &source)
 512         {
 513                 // for ScrollPanelEventListener
 514                 if (__subControlMoved)
 515                 {
 516                         __pScrollPanel->FireScrollPanelEvent(source, CORE_OTHER_CONTROL_SELECTED);
 517                 }
 518         }
 519
 520         __pPressedControl = null;
 521         __subControlMoved = false;
 522
 523         if (!__scrollAnimationRunning)
 524         {
 525                 RollbackBouncing(true);
 526                 r = GetLastResult();
 527                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 528
 529                 FadeOutScrollBar();
 530                 r = GetLastResult();
 531                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 532
 533                 if (__scrollOccured)
 534                 {
 535                         __scrollOccured = false;
 536                         __pScrollPanel->FireOnScrollStoppedEvent();
 537                 }
 538         }
 539
 540         return r;
 541 }
 542
 543 result
 544 _ScrollPanelPresenter::RunPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 545 {
 546         result r = E_SUCCESS;
 547
 548         if (__pPressedControl != &source)
 549         {
 550                 return r;
 551         }
 552
 553         __touchPressed = false;
 554         __firstTouchMove = true;
 555
 556         __pPressedControl = null;
 557         __subControlMoved = false;
 558
 559         if (!__scrollAnimationRunning)
 560         {
 561                 RollbackBouncing(true);
 562                 r = GetLastResult();
 563                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 564
 565                 FadeOutScrollBar();
 566                 r = GetLastResult();
 567                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 568         }
 569
 570         if (__scrollOccured && !__scrollAnimationRunning)
 571         {
 572                 __scrollOccured = false;
 573                 __pScrollPanel->FireOnScrollStoppedEvent();
 574         }
 575
 576         return r;
 577 }
 578
 579 _UiTouchEventDelivery
 580 _ScrollPanelPresenter::OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
 581 {
 582         result r = RunPreviewTouchPressed(source, touchInfo);
 583         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, _UI_TOUCH_EVENT_DELIVERY_YES, r, "[%s] Propagating.", GetErrorMessage(r));
 584
 585         return _UI_TOUCH_EVENT_DELIVERY_FORCED_YES;
 586 }
 587
 588 _UiTouchEventDelivery
 589 _ScrollPanelPresenter::OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
 590 {
 591         RunPreviewTouchMoved(source, touchInfo);
 592
 593         return _UI_TOUCH_EVENT_DELIVERY_YES;
 594 }
 595
 596 _UiTouchEventDelivery
 597 _ScrollPanelPresenter::OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 598 {
 599         result r = RunPreviewTouchReleased(source, touchInfo);
 600         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, _UI_TOUCH_EVENT_DELIVERY_YES, r, "[%s] Propagating.", GetErrorMessage(r));
 601
 602         return _UI_TOUCH_EVENT_DELIVERY_FORCED_YES;
 603 }
 604
 605 _UiTouchEventDelivery
 606 _ScrollPanelPresenter::OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
 607 {
 608         result r = RunPreviewTouchCanceled(source, touchInfo);
 609         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, _UI_TOUCH_EVENT_DELIVERY_YES, r, "[%s] Propagating.", GetErrorMessage(r));
 610
 611         return _UI_TOUCH_EVENT_DELIVERY_YES;
 612 }
 613
 614 bool
 615 _ScrollPanelPresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
 616 {
 617         if (__pScrollPanel != &source)
 618         {
 619                 return false;
 620         }
 621
 622         result r = RunPreviewTouchPressed(source, touchInfo);
 623         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 624
 625         return true;
 626 }
 627
 628 bool
 629 _ScrollPanelPresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
 630 {
 631         if (__pPressedControl != &source)
 632         {
 633                 return false;
 634         }
 635
 636         if (!__touchPressed)
 637         {
 638                 return false;
 639         }
 640
 641         if (!IsScrollable())
 642         {
 643                 return false;
 644         }
 645
 646         if (__currentMovedPosition != touchInfo.GetCurrentPosition())
 647         {
 648                 RunPreviewTouchMoved(source, touchInfo);
 649         }
 650
 651         // calculate move distance
 652         ScrollPanelScrollDirection scrollDirection = __pScrollPanel->GetScrollDirection();
 653         ScrollInputMode scrollInputMode = __pScrollPanel->GetScrollInputMode();
 654         int scrollDistance = 0;
 655         int scrollDistanceX = __previousTouchedPosition.x - __currentMovedPosition.x;
 656         int scrollDistanceY = __previousTouchedPosition.y - __currentMovedPosition.y;
 657
 658         if (scrollInputMode == SCROLL_INPUT_MODE_RESTRICT_TO_INITIAL_DIRECTION)
 659         {
 660                 if (scrollDirection == __firstScrollMoveDirection)
 661                 {
 662                         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 663                         {
 664                                 scrollDistance = scrollDistanceX;
 665                         }
 666                         else if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL)
 667                         {
 668                                 scrollDistance = scrollDistanceY;
 669                         }
 670                 }
 671                 else
 672                 {
 673                         RollbackBouncing(true);
 674                         result r = GetLastResult();
 675                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 676
 677                         FadeOutScrollBar();
 678                         r = GetLastResult();
 679                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 680
 681                         if ((__firstScrollMoveDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL && abs(scrollDistanceY) > abs(scrollDistanceX))
 682                                 || (__firstScrollMoveDirection == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL && abs(scrollDistanceY) < abs(scrollDistanceX)))
 683                         {
 684                                 return true;
 685                         }
 686                         else
 687                         {
 688                                 return false;
 689                         }
 690                 }
 691         }
 692         else
 693         {
 694                 if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 695                 {
 696                         if (abs(scrollDistanceY) <= abs(scrollDistanceX))
 697                         {
 698                                 scrollDistance = scrollDistanceX;
 699                         }
 700                         else
 701                         {
 702                                 return false;
 703                         }
 704                 }
 705                 else if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL)
 706                 {
 707                         if (abs(scrollDistanceY) >= abs(scrollDistanceX))
 708                         {
 709                                 scrollDistance = scrollDistanceY;
 710                         }
 711                         else
 712                         {
 713                                 return false;
 714                         }
 715                 }
 716         }
 717
 718         if (scrollDistance != 0)
 719         {
 720                 FadeInScrollBar();
 721                 result r = GetLastResult();
 722                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 723
 724                 int realMoveDistance = ScrollTo(scrollDistance + GetScrollPositionInternal());
 725                 r = GetLastResult();
 726                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 727
 728                 if (realMoveDistance == 0)
 729                 {
 730                         // not moved and bubbling
 731                         if (scrollInputMode == SCROLL_INPUT_MODE_RESTRICT_TO_INITIAL_DIRECTION)
 732                         {
 733                                 if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 734                                 {
 735                                         if (abs(scrollDistanceY) < abs(scrollDistanceX))
 736                                         {
 737                                                 return false;
 738                                         }
 739                                         else
 740                                         {
 741                                                 return true;
 742                                         }
 743                                 }
 744                                 else if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL)
 745                                 {
 746                                         if (abs(scrollDistanceY) > abs(scrollDistanceX))
 747                                         {
 748                                                 return false;
 749                                         }
 750                                         else
 751                                         {
 752                                                 return true;
 753                                         }
 754                                 }
 755                         }
 756                         else
 757                         {
 758                                 return false;
 759                         }
 760                 }
 761         }
 762         else
 763         {
 764                 return true;
 765         }
 766
 767         return true;
 768 }
 769
 770 bool
 771 _ScrollPanelPresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 772 {
 773         if (__pPressedControl != &source)
 774         {
 775                 return false;
 776         }
 777
 778         if (__pScrollPanel != &source)
 779         {
 780                 return false;
 781         }
 782
 783         result r = RunPreviewTouchReleased(source, touchInfo);
 784         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 785
 786         return true;
 787 }
 788
 789 bool
 790 _ScrollPanelPresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchInfo)
 791 {
 792         if (__pPressedControl != &source)
 793         {
 794                 return false;
 795         }
 796
 797         if (__pScrollPanel != &source)
 798         {
 799                 return false;
 800         }
 801
 802         result r = RunPreviewTouchCanceled(source, touchInfo);
 803         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 804
 805         return true;
 806 }
 807
 808 void
 809 _ScrollPanelPresenter::OnTouchMoveHandled(const _Control& control)
 810 {
 811         RollbackBouncing(true);
 812         result r = GetLastResult();
 813         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 814
 815         FadeOutScrollBar();
 816         r = GetLastResult();
 817         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 818 }
 819
 820 void
 821 _ScrollPanelPresenter::OnScrollEndReached(_Control& source, ScrollEndEvent type)
 822 {
 823 }
 824
 825 void
 826 _ScrollPanelPresenter::OnScrollPositionChanged(_Control& source, int scrollPos)
 827 {
 828         if (&source != __pScrollPanel->GetScrollBar())
 829         {
 830                 return;
 831         }
 832
 833         // JumpToTop
 834         if (scrollPos == 0)
 835         {
 836                 SetScrollPosition(scrollPos, true);
 837         }
 838         else
 839         {
 840                 FadeInScrollBar();
 841                 result r = GetLastResult();
 842                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 843
 844                 SetScrollPosition(scrollPos, false);
 845         }
 846 }
 847
 848 bool
 849 _ScrollPanelPresenter::DoFlickGestureRecognized(_TouchFlickGestureDetector& gesture)
 850 {
 851         if (!IsScrollable())
 852         {
 853                 return false;
 854         }
 855
 856         Rectangle scrollArea = GetScrollAreaBounds();
 857         Rectangle scrollPanelBounds = __pScrollPanel->GetBounds();
 858
 859         int distanceX = 0;
 860         int distanceY = 0;
 861         gesture.GetDistance(distanceX, distanceY);
 862         _FlickDirection moveDirection = gesture.GetDirection();
 863
 864         if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 865         {
 866                 if (moveDirection != _FLICK_DIRECTION_RIGHT && moveDirection != _FLICK_DIRECTION_LEFT)
 867                 {
 868                         return false;
 869                 }
 870
 871                 if (distanceX < 0)
 872                 {
 873                         moveDirection = _FLICK_DIRECTION_LEFT;
 874                 }
 875                 else if (distanceX > 0)
 876                 {
 877                         moveDirection = _FLICK_DIRECTION_RIGHT;
 878                 }
 879         }
 880         else
 881         {
 882                 if (moveDirection != _FLICK_DIRECTION_DOWN && moveDirection != _FLICK_DIRECTION_UP)
 883                 {
 884                         return false;
 885                 }
 886
 887                 if (distanceY < 0)
 888                 {
 889                         moveDirection = _FLICK_DIRECTION_UP;
 890                 }
 891                 else if (distanceY > 0)
 892                 {
 893                         moveDirection = _FLICK_DIRECTION_DOWN;
 894                 }
 895         }
 896
 897         if (__pScrollPanel->IsPageScrollEnabled() && __pScrollPanel->IsPageScrollFlickMoveLimitedOnePage())
 898         {
 899                 int targetPosition = 0;
 900                 int currentScrollPosition = GetScrollPosition();
 901
 902                 if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 903                 {
 904                         int pageSize = __pScrollPanel->GetPageScrollAlignSize().width;
 905
 906                         // to right page
 907                         if (distanceX < 0)
 908                         {
 909                                 targetPosition = currentScrollPosition - (currentScrollPosition % pageSize) + pageSize;
 910                         }
 911                         // to left page
 912                         else if (distanceX > 0)
 913                         {
 914                                 targetPosition = currentScrollPosition - (currentScrollPosition % pageSize);
 915                         }
 916                 }
 917                 else
 918                 {
 919                         int pageSize = __pScrollPanel->GetPageScrollAlignSize().height;
 920
 921                         // to up page
 922                         if (distanceX < 0)
 923                         {
 924                                 targetPosition = currentScrollPosition - (currentScrollPosition % pageSize) + pageSize;
 925                         }
 926                         // to down page
 927                         else if (distanceX > 0)
 928                         {
 929                                 targetPosition = currentScrollPosition - (currentScrollPosition % pageSize);
 930                         }
 931                 }
 932
 933                 targetPosition = FixScrollPositionIntoScrollAreaBounds(targetPosition);
 934                 if (targetPosition == currentScrollPosition)
 935                 {
 936                         return false;
 937                 }
 938
 939                 __flickRunning = true;
 940
 941                 ScrollTo(targetPosition, true);
 942                 result r = GetLastResult();
 943                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 944
 945                 FadeInScrollBar();
 946                 r = GetLastResult();
 947                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 948
 949                 return true;
 950         }
 951         else
 952         {
 953                 int moveAmount = 0;
 954                 int flickAmount = 0;
 955
 956                 // calculate flick amount
 957                 if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 958                 {
 959                         flickAmount = CalculateFlickAmount(distanceX, gesture.GetDuration());
 960                 }
 961                 else
 962                 {
 963                         flickAmount = CalculateFlickAmount(distanceY, gesture.GetDuration());
 964                 }
 965
 966                 moveAmount = -flickAmount;
 967
 968                 // page align
 969                 if (__pScrollPanel->IsPageScrollEnabled())
 970                 {
 971                         int scrollPosition = 0;
 972                         int maxPosition = 0;
 973                         int pageSize = 0;
 974
 975                         if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
 976                         {
 977                                 pageSize = __pScrollPanel->GetPageScrollAlignSize().width;
 978                                 maxPosition = scrollArea.width - pageSize;
 979                                 scrollPosition = __pScrollPanelModel->GetCurrentHorizontalScrollPosition();
 980                         }
 981                         else
 982                         {
 983                                 pageSize = __pScrollPanel->GetPageScrollAlignSize().height;
 984                                 maxPosition = scrollArea.height - pageSize;
 985                                 scrollPosition = __pScrollPanelModel->GetCurrentVerticalScrollPosition();
 986                         }
 987
 988                         int pageGap = (scrollPosition + moveAmount) % pageSize;
 989                         int lowerPageIndex = (scrollPosition + moveAmount) / pageSize;
 990                         int targetPageMin = pageSize * lowerPageIndex;
 991                         int targetPageMax = targetPageMin + pageSize;
 992                         targetPageMin = targetPageMax > maxPosition ? (maxPosition / pageSize) * pageSize : targetPageMin;
 993                         targetPageMax = targetPageMax > maxPosition ? maxPosition : targetPageMax;
 994
 995                         if (pageGap <= targetPageMax - targetPageMin - pageGap)
 996                         {
 997                                 moveAmount = targetPageMin - scrollPosition;
 998                         }
 999                         else
1000                         {
1001                                 moveAmount = targetPageMax - scrollPosition;
1002                         }
1003                 }
1004
1005                 if (moveAmount != 0)
1006                 {
1007                         // scroll with animation
1008                         __flickRunning = true;
1009
1010                         __flickCount++;
1011                         if (__flickCount >= 3)
1012                         {
1013                                 // flick finger gesture
1014                                 if (__flickDirection != moveDirection)
1015                                 {
1016                                         StopFlickScrollEffectTimer();
1017                                         __flickCount++;
1018                                 }
1019                                 else
1020                                 {
1021                                         switch (__flickDirection)
1022                                         {
1023                                         case _FLICK_DIRECTION_UP:
1024                                                 ScrollToBottom();
1025                                                 break;
1026                                         case _FLICK_DIRECTION_DOWN:
1027                                                 ScrollToTop();
1028                                                 break;
1029                                         case _FLICK_DIRECTION_LEFT:
1030                                                 ScrollToRight();
1031                                                 break;
1032                                         case _FLICK_DIRECTION_RIGHT:
1033                                                 ScrollToLeft();
1034                                                 break;
1035                                         default:
1036                                                         break;
1037                                         }
1038
1039                                         return true;
1040                                 }
1041                         }
1042
1043                         // normal flick
1044                         if (__flickCount == 1)
1045                         {
1046                                 __flickDirection = moveDirection;
1047                                 StartFlickScrollEffectTimer();
1048                         }
1049                         else
1050                         {
1051                                 if (__flickDirection != moveDirection)
1052                                 {
1053                                         StopFlickScrollEffectTimer();
1054                                         __flickCount++;
1055
1056                                         __flickDirection = moveDirection;
1057                                         StartFlickScrollEffectTimer();
1058                                 }
1059                         }
1060
1061                         // limited flick amount
1062                         int targetPosition = moveAmount + GetScrollPositionInternal();
1063                         int scrollToPosition = FixScrollPositionIntoScrollAreaBounds(targetPosition);
1064                         if (abs(scrollToPosition - targetPosition) > SCROLL_PANEL_OVERSCROLLING_MAX_DISTANCCE)
1065                         {
1066                                 switch (moveDirection)
1067                                 {
1068                                 case _FLICK_DIRECTION_UP:
1069                                         targetPosition = scrollArea.height - scrollPanelBounds.height + SCROLL_PANEL_OVERSCROLLING_MAX_DISTANCCE;
1070                                         break;
1071                                 case _FLICK_DIRECTION_DOWN:
1072                                         targetPosition = scrollArea.y - SCROLL_PANEL_OVERSCROLLING_MAX_DISTANCCE;
1073                                         break;
1074                                 case _FLICK_DIRECTION_LEFT:
1075                                         targetPosition = scrollArea.width - scrollPanelBounds.width + SCROLL_PANEL_OVERSCROLLING_MAX_DISTANCCE;
1076                                         break;
1077                                 case _FLICK_DIRECTION_RIGHT:
1078                                         targetPosition = scrollArea.x - SCROLL_PANEL_OVERSCROLLING_MAX_DISTANCCE;
1079                                         break;
1080                                 default:
1081                                         break;
1082                                 }
1083                         }
1084
1085                         ScrollTo(targetPosition, true);
1086                         result r = GetLastResult();
1087                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1088
1089                         FadeInScrollBar();
1090                         r = GetLastResult();
1091                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1092
1093                         return true;
1094                 }
1095                 else
1096                 {
1097                         StopFlickScrollEffectTimer();
1098
1099                         return false;
1100                 }
1101         }
1102 }
1103
1104 bool
1105 _ScrollPanelPresenter::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
1106 {
1107         return DoFlickGestureRecognized(gesture);
1108 }
1109
1110 bool
1111 _ScrollPanelPresenter::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
1112 {
1113         StopScrollingAnimation();
1114         RollbackBouncing(true);
1115
1116         return false;
1117 }
1118
1119 bool
1120 _ScrollPanelPresenter::IsControlOutOfView(const _Control& control) const
1121 {
1122         Rectangle controlBounds = control.GetBounds();
1123         int scrollPos = __pScrollPanel->GetScrollPosition();
1124
1125         // is control out of view area
1126         if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1127         {
1128                 if (controlBounds.x < scrollPos || controlBounds.x + controlBounds.width > scrollPos + __pScrollPanel->GetBounds().width)
1129                 {
1130                         return true;
1131                 }
1132         }
1133         else
1134         {
1135                 if (controlBounds.y < scrollPos || controlBounds.y + controlBounds.height > scrollPos + __pScrollPanel->GetBounds().height)
1136                 {
1137                         return true;
1138                 }
1139         }
1140
1141         return false;
1142 }
1143
1144 void
1145 _ScrollPanelPresenter::ScrollToControlWhenOutOfView(const _Control& control)
1146 {
1147         if (IsControlOutOfView(control))
1148         {
1149                 ScrollToControl(const_cast<const _Control&>(control));
1150                 result r = GetLastResult();
1151                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1152         }
1153 }
1154
1155 void
1156 _ScrollPanelPresenter::RollbackBouncing(bool withAnimation)
1157 {
1158         if (!IsScrollable())
1159         {
1160                 return;
1161         }
1162
1163         int scrollPosition = GetScrollPositionInternal();
1164         int fixedScrollPosition = FixScrollPositionIntoScrollAreaBounds(scrollPosition);
1165         if (scrollPosition != fixedScrollPosition)
1166         {
1167                 FadeInScrollBar();
1168                 result r = GetLastResult();
1169                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1170
1171                 ScrollTo(fixedScrollPosition, withAnimation);
1172                 r = GetLastResult();
1173                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1174         }
1175 }
1176
1177 bool
1178 _ScrollPanelPresenter::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1179 {
1180         const _Control& controlObj = control.GetOwner();
1181         ScrollToControlWhenOutOfView(controlObj);
1182         result r = GetLastResult();
1183         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1184
1185         return false;
1186 }
1187
1188 bool
1189 _ScrollPanelPresenter::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1190 {
1191         const _Control& controlObj = control.GetOwner();
1192         ScrollToControlWhenOutOfView(controlObj);
1193         result r = GetLastResult();
1194         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1195
1196         return false;
1197 }
1198
1199 bool
1200 _ScrollPanelPresenter::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1201 {
1202         return false;
1203 }
1204
1205 bool
1206 _ScrollPanelPresenter::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1207 {
1208         return false;
1209 }
1210
1211 bool
1212 _ScrollPanelPresenter::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1213 {
1214         return false;
1215 }
1216
1217 bool
1218 _ScrollPanelPresenter::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1219 {
1220         return false;
1221 }
1222
1223 void
1224 _ScrollPanelPresenter::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
1225 {
1226         if (&timer == __pScrollBarLoadEffectTimer)
1227         {
1228                 __scrollBarFirstLoaded = false;
1229
1230                 StopScrollBarLoadEffectTimer();
1231
1232                 FadeOutScrollBar();
1233                 result r = GetLastResult();
1234                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1235         }
1236         else if (&timer == __pFlickScrollEffectTimer)
1237         {
1238                 StopFlickScrollEffectTimer();
1239         }
1240 }
1241
1242 int
1243 _ScrollPanelPresenter::CalculateFlickAmount(int flickDistance, int flickDuration)
1244 {
1245         int flickAmount = ((((flickDistance * SCROLL_PANEL_FLICK_IN_PIXEL_UNIT) / flickDuration) * SCROLL_PANEL_FLICK_WEIGHT_VELOCITY) + (flickDistance * SCROLL_PANEL_FLICK_WEIGHT_DISTANCE)) / SCROLL_PANEL_FLICK_ALPHA_PER_PIXEL;
1246
1247         return flickAmount;
1248 }
1249
1250 void
1251 _ScrollPanelPresenter::OnVisualElementAnimationStarted(const VisualElementAnimation& animation, const String& keyName, VisualElement& target)
1252 {
1253         // nothing
1254 }
1255
1256 void
1257 _ScrollPanelPresenter::OnVisualElementAnimationRepeated(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, long currentRepeatCount)
1258 {
1259         // nothing
1260 }
1261
1262 void
1263 _ScrollPanelPresenter::OnVisualElementAnimationFinished(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, bool completedNormally)
1264 {
1265         __scrollAnimationRunning = false;
1266         __flickRunning = false;
1267
1268         if (__scrollOccured)
1269         {
1270                 __scrollOccured = false;
1271                 __pScrollPanel->FireOnScrollStoppedEvent();
1272         }
1273
1274         if (completedNormally)
1275         {
1276                 RollbackBouncing(true);
1277                 result r = GetLastResult();
1278                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1279         }
1280         else
1281         {
1282                 int scrollPosition = GetScrollPositionInternal();
1283                 int targetPosition = GetScrollPosition();
1284                 if (scrollPosition != targetPosition)
1285                 {
1286                         ChangeScrollBarPosition(targetPosition);
1287                         SetScrollPositionInternal(targetPosition);
1288                 }
1289         }
1290
1291         FadeOutScrollBar();
1292         result r = GetLastResult();
1293         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1294 }
1295
1296 void
1297 _ScrollPanelPresenter::OnTickOccurred(const VisualElementAnimation& animation, const String& keyName, VisualElement& target, const Variant& currentValue)
1298 {
1299         _VisualElement* pVisualElement = __pScrollPanel->GetVisualElement();
1300
1301         if (&target != pVisualElement)
1302         {
1303                 return;
1304         }
1305
1306         if (keyName == SCROLLING_ANIMATION_NAME)
1307         {
1308                 if (!__scrollAnimationRunning)
1309                 {
1310                         return;
1311                 }
1312
1313                 ScrollToInternal(currentValue.ToInt());
1314         }
1315 }
1316
1317 void
1318 _ScrollPanelPresenter::UpdateLayout(void)
1319 {
1320         __pScrollPanel->PartialUpdateLayout();
1321 }
1322
1323 void
1324 _ScrollPanelPresenter::AdjustModel()
1325 {
1326         _Scroll* pHorizontalScrollBar = __pScrollPanel->GetHorizontalScrollBar();
1327         _Scroll* pVerticalScrollBar = __pScrollPanel->GetVerticalScrollBar();
1328
1329         Rectangle scrollPanelBounds = __pScrollPanel->GetBounds();
1330         ScrollPanelScrollDirection scrollDirection = __pScrollPanel->GetScrollDirection();
1331
1332
1333         Rectangle scrollArea = Rectangle(0, 0, scrollPanelBounds.width, scrollPanelBounds.height);
1334
1335         if (__pScrollPanel->IsScrollAreaAutoResizingEnabled())
1336         {
1337                 int count = __pScrollPanel->GetChildCount();
1338
1339                 if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL)
1340                 {
1341                         for (int i = 0; i < count; i++)
1342                         {
1343                                 _Control* pControl = __pScrollPanel->GetChild(i);
1344                                 SysTryReturnVoidResult(NID_UI_CTRL, pControl != null, E_SYSTEM, "[%s] pControl(child) is invalid pointer.", GetErrorMessage(E_SYSTEM));
1345
1346                                 if (pControl == pVerticalScrollBar || pControl == pHorizontalScrollBar)
1347                                 {
1348                                         continue;
1349                                 }
1350
1351                                 int targetMaxPos = pControl->GetBounds().GetBottomRight().y;
1352                                 scrollArea.height = (scrollArea.height < targetMaxPos) ? targetMaxPos : scrollArea.height;
1353                         }
1354                 }
1355                 else if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1356                 {
1357                         for (int i = 0; i < count; i++)
1358                         {
1359                                 _Control* pControl = __pScrollPanel->GetChild(i);
1360                                 SysTryReturnVoidResult(NID_UI_CTRL, pControl != null, E_SYSTEM, "[%s] pControl(child) is invalid pointer.", GetErrorMessage(E_SYSTEM));
1361
1362                                 if (pControl == pVerticalScrollBar || pControl == pHorizontalScrollBar)
1363                                 {
1364                                         continue;
1365                                 }
1366
1367                                 int targetMaxPos = pControl->GetBounds().GetBottomRight().x;
1368                                 scrollArea.width = (scrollArea.width < targetMaxPos) ? targetMaxPos : scrollArea.width;
1369                         }
1370                 }
1371         }
1372         else
1373         {
1374                 scrollArea = GetScrollAreaBounds();
1375                 if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1376                 {
1377                         scrollArea.width = scrollArea.width < scrollPanelBounds.width ? scrollPanelBounds.width : scrollArea.width;
1378                         scrollArea.height = scrollPanelBounds.height;
1379                 }
1380                 else
1381                 {
1382                         scrollArea.width = scrollPanelBounds.width;
1383                         scrollArea.height = scrollArea.height < scrollPanelBounds.height ? scrollPanelBounds.height : scrollArea.height;
1384                 }
1385         }
1386
1387         // before change model ScrollPosition fix
1388         int scrollPosition = GetScrollPosition();
1389         int fixedScrollPosition = FixScrollPositionIntoScrollAreaBounds(scrollPosition, scrollPanelBounds, scrollArea);
1390         if (scrollPosition != fixedScrollPosition)
1391         {
1392                 ScrollTo(fixedScrollPosition, false);
1393                 result r = GetLastResult();
1394                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1395         }
1396
1397         // change model values
1398         SetScrollAreaBoundsInternal(scrollArea);
1399         Dimension alignSize = Dimension(scrollPanelBounds.width, scrollPanelBounds.height);
1400         __pScrollPanel->SetPageScrollAlignSize(alignSize);
1401
1402         // Adjust ScrollBar
1403         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1404         {
1405                 if (scrollPanelBounds.width > 0 && scrollArea.width > scrollPanelBounds.width)
1406                 {
1407                         if (pHorizontalScrollBar != null)
1408                         {
1409                                 pHorizontalScrollBar->OnParentBoundsChanged();
1410
1411                                 // update scrollbar range
1412                                 ChangeScrollBarRange();
1413                                 result r = GetLastResult();
1414                                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1415                         }
1416                 }
1417                 else
1418                 {
1419                         SetScrollPosition(scrollArea.x, false);
1420                         result r = GetLastResult();
1421                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1422                 }
1423         }
1424         else
1425         {
1426                 if (scrollPanelBounds.height > 0 && scrollArea.height > scrollPanelBounds.height)
1427                 {
1428                         if (pVerticalScrollBar != null)
1429                         {
1430                                 pVerticalScrollBar->OnParentBoundsChanged();
1431
1432                                 // update scrollbar range
1433                                 ChangeScrollBarRange();
1434                                 result r = GetLastResult();
1435                                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1436                         }
1437                 }
1438                 else
1439                 {
1440                         SetScrollPosition(scrollArea.y, false);
1441                         result r = GetLastResult();
1442                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1443                 }
1444         }
1445
1446         if (!__scrollAnimationRunning)
1447         {
1448                 FadeOutScrollBar();
1449                 result r = GetLastResult();
1450                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1451         }
1452 }
1453
1454 bool
1455 _ScrollPanelPresenter::ScrollToControl(const _Control& source)
1456 {
1457         if (__pScrollPanel->GetChildCount() == 0)
1458         {
1459                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[%s] ScrollPanel have no child control.", GetErrorMessage(E_INVALID_ARG));
1460                 return false;
1461         }
1462
1463         int validNum = __pScrollPanel->GetChildIndex(source);
1464
1465         if (validNum == -1)
1466         {
1467                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[%s] source is not a child control.", GetErrorMessage(E_INVALID_ARG));
1468                 return false;
1469         }
1470
1471         if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1472         {
1473                 //align source control to left position.
1474                 SetHorizontalScrollPosition(source.GetBounds().x);
1475                 result r = GetLastResult();
1476                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1477         }
1478         else
1479         {
1480                 //align source control to top position.
1481                 SetVerticalScrollPosition(source.GetBounds().y);
1482                 result r = GetLastResult();
1483                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1484         }
1485
1486         return true;
1487 }
1488
1489 int
1490 _ScrollPanelPresenter::ScrollTo(int targetPosition)
1491 {
1492         return ScrollTo(targetPosition, false);
1493 }
1494
1495
1496 int
1497 _ScrollPanelPresenter::ScrollTo(int targetPosition, bool withAnimation)
1498 {
1499         StopScrollingAnimation();
1500
1501         if (withAnimation)
1502         {
1503                 // Calculate real move distance
1504                 int scrollToPosition = FixScrollPositionIntoScrollAreaBounds(targetPosition);
1505
1506                 int oldPosition = GetScrollPositionInternal();
1507                 VisualElementValueAnimation* pScrollingAnimation = __pScrollPanel->GetScrollingAnimation();
1508                 pScrollingAnimation->SetStartValue(Variant(oldPosition));
1509                 pScrollingAnimation->SetEndValue(Variant(targetPosition));
1510                 pScrollingAnimation->SetDuration(SCROLL_PANEL_SCROLLING_ANIMATION_DURATION);
1511                 _VisualElement* pVisualElement = __pScrollPanel->GetVisualElement();
1512                 __scrollAnimationRunning = true;
1513                 pVisualElement->AddAnimation(SCROLLING_ANIMATION_NAME, *pScrollingAnimation);
1514
1515                 return scrollToPosition - oldPosition;
1516         }
1517         else
1518         {
1519                 return ScrollToInternal(targetPosition);
1520         }
1521 }
1522
1523
1524 int
1525 _ScrollPanelPresenter::ScrollToInternal(int targetPosition)
1526 {
1527         ScrollPanelScrollDirection scrollDirection = __pScrollPanel->GetScrollDirection();
1528         _VisualElement* pVisualElement = __pScrollPanel->GetVisualElement();
1529         int previousScrollPosition = GetScrollPositionInternal();
1530         int distance = 0;
1531         FloatPoint floatPointDistance;
1532
1533         int scrollToPosition = FixScrollPositionIntoScrollAreaBounds(targetPosition);
1534
1535         if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1536         {
1537                 distance = scrollToPosition - FixScrollPositionIntoScrollAreaBounds(previousScrollPosition);
1538                 floatPointDistance.SetPosition(-distance, 0.0f);
1539         }
1540         else
1541         {
1542                 distance = scrollToPosition - FixScrollPositionIntoScrollAreaBounds(previousScrollPosition);
1543                 floatPointDistance.SetPosition(0.0f, -distance);
1544         }
1545
1546         if (distance != 0)
1547         {
1548                 result r = pVisualElement->ScrollByPoint(floatPointDistance, false);
1549                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, 0, r, "[%s] Propagating.", GetErrorMessage(r));
1550
1551                 __scrollOccured = true;
1552         }
1553
1554         ChangeScrollBarPosition(targetPosition);
1555         SetScrollPositionInternal(targetPosition);
1556
1557         if (distance != 0)
1558         {
1559                 Rectangle scrollPanelBounds = __pScrollPanel->GetBounds();
1560                 Rectangle scrollArea = GetScrollAreaBounds();
1561
1562                 if (scrollDirection == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1563                 {
1564                         if (scrollArea.width > scrollPanelBounds.width)
1565                         {
1566                                 int minScrollPos = scrollArea.x;
1567                                 int maxScrollPos = scrollArea.width - scrollPanelBounds.width;
1568
1569                                 if ((targetPosition >= minScrollPos && targetPosition <= maxScrollPos)
1570                                         || (previousScrollPosition > minScrollPos || previousScrollPosition < maxScrollPos))
1571                                 {
1572                                         __pScrollPanel->FireOnScrollPositionChangedEvent();
1573                                 }
1574
1575                                 if (previousScrollPosition > minScrollPos && previousScrollPosition < maxScrollPos)
1576                                 {
1577                                         if (targetPosition <= minScrollPos)
1578                                         {
1579                                                 __pScrollPanel->FireOnScrollEndEvent(SCROLL_END_EVENT_END_LEFT);
1580                                         }
1581                                         else if (targetPosition >= maxScrollPos)
1582                                         {
1583                                                 __pScrollPanel->FireOnScrollEndEvent(SCROLL_END_EVENT_END_RIGHT);
1584                                         }
1585                                 }
1586                         }
1587                 }
1588                 else
1589                 {
1590                         if (scrollArea.height > scrollPanelBounds.height)
1591                         {
1592                                 int minScrollPos = scrollArea.y;
1593                                 int maxScrollPos = scrollArea.height - scrollPanelBounds.height;
1594
1595                                 if ((targetPosition >= minScrollPos && targetPosition <= maxScrollPos)
1596                                         || (previousScrollPosition > minScrollPos || previousScrollPosition < maxScrollPos))
1597                                 {
1598                                         __pScrollPanel->FireOnScrollPositionChangedEvent();
1599                                 }
1600
1601                                 if (previousScrollPosition > minScrollPos && previousScrollPosition < maxScrollPos)
1602                                 {
1603                                         if (targetPosition <= minScrollPos)
1604                                         {
1605                                                 __pScrollPanel->FireOnScrollEndEvent(SCROLL_END_EVENT_END_TOP);
1606                                         }
1607                                         else if (targetPosition >= maxScrollPos)
1608                                         {
1609                                                 __pScrollPanel->FireOnScrollEndEvent(SCROLL_END_EVENT_END_BOTTOM);
1610                                         }
1611                                 }
1612                         }
1613                 }
1614         }
1615
1616         return distance;
1617 }
1618
1619 void
1620 _ScrollPanelPresenter::ChangeScrollBarPosition(int position)
1621 {
1622         _Scroll* pScrollBar = __pScrollPanel->GetScrollBar();
1623
1624         if (pScrollBar != null && __pScrollPanel->IsAncestorOf(*pScrollBar))
1625         {
1626                 if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1627                 {
1628                         result r = pScrollBar->SetScrollPosition(position);
1629                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1630                 }
1631                 else
1632                 {
1633                         result r = pScrollBar->SetScrollPosition(position);
1634                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1635                 }
1636         }
1637 }
1638
1639 void
1640 _ScrollPanelPresenter::ChangeScrollBarRange(void)
1641 {
1642         _Scroll* pScrollBar = __pScrollPanel->GetScrollBar();
1643
1644         if (pScrollBar != null)
1645         {
1646                 int viewRange = 0;
1647                 int scrollRange = 0;
1648
1649                 if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1650                 {
1651                         viewRange = __pScrollPanel->GetBounds().width;
1652                         scrollRange = GetScrollAreaBounds().width;
1653                 }
1654                 else
1655                 {
1656                         viewRange = __pScrollPanel->GetBounds().height;
1657                         scrollRange = GetScrollAreaBounds().height;
1658                 }
1659
1660                 if (viewRange <= scrollRange)
1661                 {
1662                         result r = pScrollBar->SetScrollRange(viewRange, scrollRange);
1663                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1664
1665                         if (viewRange != scrollRange && __scrollBarFirstLoaded)
1666                         {
1667                                 FadeInScrollBar();
1668                                 result r = GetLastResult();
1669                                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1670
1671                                 StartScrollBarLoadEffectTimer();
1672                                 r = GetLastResult();
1673                                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1674                         }
1675                 }
1676         }
1677 }
1678
1679 void
1680 _ScrollPanelPresenter::StartScrollBarLoadEffectTimer(void)
1681 {
1682         result r = E_SUCCESS;
1683
1684         if (__pScrollBarLoadEffectTimer == null)
1685         {
1686                 __pScrollBarLoadEffectTimer = new (std::nothrow) Tizen::Base::Runtime::Timer;
1687                 SysTryReturnVoidResult(NID_UI_CTRL, __pScrollBarLoadEffectTimer != null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient", GetErrorMessage(E_OUT_OF_MEMORY));
1688
1689                 r = __pScrollBarLoadEffectTimer->Construct(*this);
1690                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1691
1692                 r = __pScrollBarLoadEffectTimer->Start(SCROLL_PANEL_SCROLL_BAR_LOAD_EFFECT_TIMER_DURATION);
1693                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1694         }
1695
1696         return;
1697
1698 CATCH:
1699         delete __pScrollBarLoadEffectTimer;
1700         __pScrollBarLoadEffectTimer = null;
1701
1702         SetLastResult(r);
1703 }
1704
1705 void
1706 _ScrollPanelPresenter::StopScrollBarLoadEffectTimer(void)
1707 {
1708         delete __pScrollBarLoadEffectTimer;
1709         __pScrollBarLoadEffectTimer = null;
1710 }
1711
1712 void
1713 _ScrollPanelPresenter::StartFlickScrollEffectTimer(void)
1714 {
1715         result r = E_SUCCESS;
1716
1717         if (__pFlickScrollEffectTimer == null)
1718         {
1719                 __pFlickScrollEffectTimer = new (std::nothrow) Tizen::Base::Runtime::Timer;
1720                 SysTryReturnVoidResult(NID_UI_CTRL, __pFlickScrollEffectTimer != null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient", GetErrorMessage(E_OUT_OF_MEMORY));
1721
1722                 r = __pFlickScrollEffectTimer->Construct(*this);
1723                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1724
1725                 r = __pFlickScrollEffectTimer->Start(SCROLL_PANEL_FLICK_SCROLL_EFFECT_TIMER_DURATION);
1726                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1727         }
1728
1729         return;
1730
1731 CATCH:
1732         delete __pFlickScrollEffectTimer;
1733         __pFlickScrollEffectTimer = null;
1734
1735         SetLastResult(r);
1736 }
1737
1738 void
1739 _ScrollPanelPresenter::StopFlickScrollEffectTimer(void)
1740 {
1741         __flickCount =  0;
1742         __flickDirection = _FLICK_DIRECTION_NONE;
1743
1744         delete __pFlickScrollEffectTimer;
1745         __pFlickScrollEffectTimer = null;
1746 }
1747
1748 void
1749 _ScrollPanelPresenter::FadeOutScrollBar(void)
1750 {
1751         if (!__scrollAnimationRunning && !__scrollBarFirstLoaded)
1752         {
1753                 _Scroll* pScrollBar = __pScrollPanel->GetScrollBar();
1754                 if (pScrollBar != null)
1755                 {
1756                         if (!pScrollBar->IsEnabledHandler())
1757                         {
1758                                 result r = pScrollBar->SetScrollVisibility(false);
1759                                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1760                         }
1761
1762                         result r = pScrollBar->SetScrollingEffectVisibility(false);
1763                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1764                 }
1765         }
1766 }
1767
1768 void
1769 _ScrollPanelPresenter::StopFadeOutScrollBar(void)
1770 {
1771         _Scroll* pScrollBar = __pScrollPanel->GetScrollBar();
1772
1773         if (pScrollBar != null)
1774         {
1775                 pScrollBar->CancelFadeEffect();
1776         }
1777 }
1778
1779 void
1780 _ScrollPanelPresenter::FadeInScrollBar(void)
1781 {
1782         if (!IsScrollable())
1783         {
1784                 return;
1785         }
1786
1787         _Scroll* pScrollBar = __pScrollPanel->GetScrollBar();
1788
1789         if (pScrollBar != null)
1790         {
1791                 if (__pScrollPanel->IsScrollBarVisible())
1792                 {
1793                         result r = pScrollBar->SetScrollVisibility(true);
1794                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1795                 }
1796
1797                 result r = pScrollBar->SetScrollingEffectVisibility(true);
1798                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1799         }
1800 }
1801
1802 bool
1803 _ScrollPanelPresenter::IsScrollable(void) const
1804 {
1805         if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1806         {
1807                 return __pScrollPanel->GetBounds().width >0 && __pScrollPanel->GetBounds().width < GetScrollAreaBounds().width;
1808         }
1809         else
1810         {
1811                 return __pScrollPanel->GetBounds().height > 0 && __pScrollPanel->GetBounds().height < GetScrollAreaBounds().height;
1812         }
1813 }
1814
1815 Rectangle
1816 _ScrollPanelPresenter::GetScrollAreaBounds(void) const
1817 {
1818         return __pScrollPanelModel->GetScrollAreaBounds();
1819 }
1820
1821 result
1822 _ScrollPanelPresenter::SetClientAreaHeight(int height)
1823 {
1824         SysTryReturn(NID_UI_CTRL, __pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_VERTICAL, E_INVALID_OPERATION, E_INVALID_OPERATION, "[%s]  The height of the client area cannot be set when the scroll direction is horizontal.", GetErrorMessage(E_INVALID_OPERATION));
1825         Rectangle bounds = GetScrollAreaBounds();
1826         bounds.height = height;
1827
1828         return SetScrollAreaBounds(bounds);
1829 }
1830
1831 result
1832 _ScrollPanelPresenter::SetClientAreaWidth(int width)
1833 {
1834         SysTryReturn(NID_UI_CTRL, __pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL, E_INVALID_OPERATION, E_INVALID_OPERATION, "[%s]  The width of the client area cannot be set when the scroll direction is vertical.", GetErrorMessage(E_INVALID_OPERATION));
1835         Rectangle bounds = GetScrollAreaBounds();
1836         bounds.width = width;
1837
1838         return SetScrollAreaBounds(bounds);
1839 }
1840
1841 void
1842 _ScrollPanelPresenter::SetScrollAreaBoundsInternal(Rectangle& bounds)
1843 {
1844         if (__pScrollPanel->IsFixingClientBoundsEnable())
1845         {
1846                 __pScrollPanel->SetClientBounds(bounds);
1847         }
1848         __pScrollPanelModel->SetScrollAreaBounds(bounds);
1849 }
1850
1851 result
1852 _ScrollPanelPresenter::SetScrollAreaBounds(Rectangle& bounds)
1853 {
1854         SysTryReturn(NID_UI_CTRL, !__pScrollPanel->IsScrollAreaAutoResizingEnabled(), E_INVALID_OPERATION, E_INVALID_OPERATION, "[%s] The width of the client area cannot be set when auto resizing of the client area is off.", GetErrorMessage(E_INVALID_OPERATION));
1855
1856         bounds.x = 0;
1857         bounds.y = 0;
1858
1859         if (__pScrollPanel->GetScrollDirection() == SCROLL_PANEL_SCROLL_DIRECTION_HORIZONTAL)
1860         {
1861                 SysTryReturn(NID_UI_CTRL, __pScrollPanel->GetBounds().width <= bounds.width, E_INVALID_ARG, E_INVALID_ARG, "[%s] width is less than the width of ScrollPanel", GetErrorMessage(E_INVALID_ARG));
1862                 bounds.height = __pScrollPanel->GetBounds().height;
1863         }
1864         else
1865         {
1866                 SysTryReturn(NID_UI_CTRL, __pScrollPanel->GetBounds().height <= bounds.height, E_INVALID_ARG, E_INVALID_ARG, "[%s] height is less than the height of ScrollPanel", GetErrorMessage(E_INVALID_ARG));
1867                 bounds.width = __pScrollPanel->GetBounds().width;
1868         }
1869
1870         // before change model ScrollPosition fix
1871         Rectangle scrollPanelBounds = __pScrollPanel->GetBounds();
1872         int scrollPosition = GetScrollPosition();
1873         int fixedScrollPosition = FixScrollPositionIntoScrollAreaBounds(scrollPosition, scrollPanelBounds, bounds);
1874         if (scrollPosition != fixedScrollPosition)
1875         {
1876                 ScrollTo(fixedScrollPosition, false);
1877                 result r = GetLastResult();
1878                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1879         }
1880
1881         SetScrollAreaBoundsInternal(bounds);
1882
1883         AdjustModel();
1884         result r = GetLastResult();
1885         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1886
1887         return E_SUCCESS;
1888 }
1889
1890 const _Control*
1891 _ScrollPanelPresenter::GetPressedControl(void) const
1892 {
1893         return __pPressedControl;
1894 }
1895
1896 Point
1897 _ScrollPanelPresenter::GetPreviousTouchPosition(void) const
1898 {
1899         return __previousTouchedPosition;
1900 }
1901
1902 Point
1903 _ScrollPanelPresenter::GetCurrentTouchPosition(void) const
1904 {
1905         return __currentMovedPosition;
1906 }
1907
1908 bool
1909 _ScrollPanelPresenter::IsScrollAnimationRunning(void) const
1910 {
1911         return __scrollAnimationRunning;
1912 }
1913
1914 }}}     // Tizen::Ui::Controls
1915