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