dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstring> // for strcmp
  23 #include <dali/public-api/animation/constraints.h>
  24 #include <dali/public-api/common/stage.h>
  25 #include <dali/public-api/events/wheel-event.h>
  26 #include <dali/public-api/events/touch-data.h>
  27 #include <dali/public-api/object/type-registry.h>
  28 #include <dali/public-api/object/type-registry-helper.h>
  29 #include <dali/integration-api/debug.h>
  30
  31 // INTERNAL INCLUDES
  32 #include <dali-toolkit/public-api/controls/scroll-bar/scroll-bar.h>
  33 #include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view.h>
  34 #include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-constraints.h>
  35 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-overshoot-indicator-impl.h>
  36 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-effect-impl.h>
  37
  38 //#define ENABLED_SCROLL_STATE_LOGGING
  39
  40 #ifdef ENABLED_SCROLL_STATE_LOGGING
  41 #define DALI_LOG_SCROLL_STATE(format, args...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, "%s:%d " format "\n", __PRETTY_FUNCTION__, __LINE__, ## args)
  42 #else
  43 #define DALI_LOG_SCROLL_STATE(format, args...)
  44 #endif
  45
  46 // TODO: Change to two class system:
  47 // 1. DraggableActor (is an actor which can be dragged anywhere, can be set to range using the ruler)
  48 // 2. ScrollView (contains a draggable actor that can a) be dragged in the negative X, and Y domain, b) has a hitArea for touches)
  49 // TODO: external components (page and status overlays).
  50 // TODO: Orientation.
  51 // TODO: upgrade Vector2/3 to support returning Unit vectors, normals, & cross product (dot product is already provided)
  52
  53 using namespace Dali;
  54
  55 namespace
  56 {
  57 const float DEFAULT_SLOW_SNAP_ANIMATION_DURATION(0.5f);             ///< Default Drag-Release animation time.
  58 const float DEFAULT_FAST_SNAP_ANIMATION_DURATION(0.25f);            ///< Default Drag-Flick animation time.
  59 const float DEFAULT_SNAP_OVERSHOOT_DURATION(0.5f);                  ///< Default Overshoot snapping animation time.
  60 const float DEFAULT_MAX_OVERSHOOT(100.0f);                          ///< Default maximum allowed overshoot in pixels
  61
  62 const float DEFAULT_AXIS_AUTO_LOCK_GRADIENT(0.36f);                 ///< Default Axis-AutoLock gradient threshold. default is 0.36:1 (20 degrees)
  63 const float DEFAULT_FRICTION_COEFFICIENT(1.0f);                     ///< Default Friction Co-efficient. (in stage diagonals per second)
  64 const float DEFAULT_FLICK_SPEED_COEFFICIENT(1.0f);                  ///< Default Flick speed coefficient (multiples input touch velocity)
  65 const float DEFAULT_MAX_FLICK_SPEED(3.0f);                          ///< Default Maximum flick speed. (in stage diagonals per second)
  66
  67 const Vector2 DEFAULT_MIN_FLICK_DISTANCE(30.0f, 30.0f);              ///< minimum distance for pan before flick allowed
  68 const float DEFAULT_MIN_FLICK_SPEED_THRESHOLD(500.0f);              ///< Minimum pan speed required for flick in pixels/s
  69 const float FREE_FLICK_SPEED_THRESHOLD = 200.0f;                    ///< Free-Flick threshold in pixels/ms
  70 const float AUTOLOCK_AXIS_MINIMUM_DISTANCE2 = 100.0f;               ///< Auto-lock axis after minimum distance squared.
  71 const float FLICK_ORTHO_ANGLE_RANGE = 75.0f;                        ///< degrees. (if >45, then supports diagonal flicking)
  72 const Vector2 DEFAULT_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION = Vector2(0.17f, 0.1f); ///< The step of horizontal scroll distance in the proportion of stage size for each wheel event received.
  73 const unsigned long MINIMUM_TIME_BETWEEN_DOWN_AND_UP_FOR_RESET( 150u );
  74 const float TOUCH_DOWN_TIMER_INTERVAL = 100.0f;
  75 const float DEFAULT_SCROLL_UPDATE_DISTANCE( 30.0f );                ///< Default distance to travel in pixels for scroll update signal
  76
  77 const std::string INTERNAL_MAX_POSITION_PROPERTY_NAME( "internalMaxPosition" );
  78
  79 // Helpers ////////////////////////////////////////////////////////////////////////////////////////
  80
  81 /**
  82  * Find the vector (distance) from (a) to (b)
  83  * in domain (start) to (end)
  84  * (\ / start)               (\ / end)
  85  *   |-a                 b<----|
  86  *
  87  * @note assumes both (a) and (b) are already with the domain
  88  * (start) to (end)
  89  *
  90  * @param[in] a the current point
  91  * @param[in] b the target point
  92  * @param[in] start the start of the domain
  93  * @param[in] end the end of the domain
  94  * @param[in] bias whether to only take the right direction or the left direction,
  95  * or the shortest direction.
  96  * @return the shortest direction and distance
  97  */
  98 float VectorInDomain(float a, float b, float start, float end, Dali::Toolkit::DirectionBias bias)
  99 {
 100   if(bias == Dali::Toolkit::DirectionBiasNone)
 101   {
 102     return ShortestDistanceInDomain( a, b, start, end );
 103   }
 104   //  (a-start + end-b)
 105   float size = end-start;
 106   float vect = b-a;
 107
 108   if(vect > 0)
 109   {
 110     // +ve vector
 111     if(bias == Dali::Toolkit::DirectionBiasRight) // going right, take the vector.
 112     {
 113       return vect;
 114     }
 115     else
 116     {
 117       float aRight = a+size;
 118       return b-aRight;
 119     }
 120   }
 121   else
 122   {
 123     // -ve vector
 124     if(bias == Dali::Toolkit::DirectionBiasLeft) // going left, take the vector.
 125     {
 126       return vect;
 127     }
 128     else
 129     {
 130       float aLeft = a-size;
 131       return b-aLeft;
 132     }
 133   }
 134 }
 135
 136 /**
 137  * Returns the position of the anchor within actor
 138  *
 139  * @param actor The Actor
 140  * @param anchor The Anchor point of interest.
 141  * @return The position of the Anchor
 142  */
 143 Vector3 GetPositionOfAnchor(Actor &actor, const Vector3 &anchor)
 144 {
 145   Vector3 childPosition = actor.GetCurrentPosition();
 146   Vector3 childAnchor = - actor.GetCurrentAnchorPoint() + anchor;
 147   Vector3 childSize = actor.GetCurrentSize();
 148
 149   return childPosition + childAnchor * childSize;
 150 }
 151
 152 // AlphaFunctions /////////////////////////////////////////////////////////////////////////////////
 153
 154 float FinalDefaultAlphaFunction(float offset)
 155 {
 156   return offset * 0.5f;
 157 }
 158
 159 /**
 160  * ConstantDecelerationAlphaFunction
 161  * Newtoninan distance for constant deceleration
 162  * v = 1 - t, s = t - 1/2 t^2
 163  * when t = 0, s = 0.0 (min distance)
 164  * when t = 1, s = 0.5 (max distance)
 165  * progress = s / (max-min) = 2t - t^2
 166  *
 167  * @param[in] offset The input progress
 168  * @return The output progress
 169  */
 170 float ConstantDecelerationAlphaFunction(float progress)
 171 {
 172   return progress * 2.0f - progress * progress;
 173 }
 174
 175 // Internal Constraints ///////////////////////////////////////////////////////////////////////////
 176
 177 /**
 178  * Internal Relative position Constraint
 179  * Generates the relative position value of the scroll view
 180  * based on the absolute position, and it's relation to the
 181  * scroll domain. This is a value from 0.0f to 1.0f in each
 182  * scroll position axis.
 183  */
 184 void InternalRelativePositionConstraint( Vector2& relativePosition, const PropertyInputContainer& inputs)
 185 {
 186   Vector2 position = -inputs[0]->GetVector2();
 187   const Vector2& min = inputs[1]->GetVector2();
 188   const Vector2& max = inputs[2]->GetVector2();
 189   const Vector3& size = inputs[3]->GetVector3();
 190
 191   position.x = WrapInDomain(position.x, min.x, max.x);
 192   position.y = WrapInDomain(position.y, min.y, max.y);
 193
 194   Vector2 domainSize = (max - min) - size.GetVectorXY();
 195
 196   relativePosition.x = domainSize.x > Math::MACHINE_EPSILON_1 ? fabsf((position.x - min.x) / domainSize.x) : 0.0f;
 197   relativePosition.y = domainSize.y > Math::MACHINE_EPSILON_1 ? fabsf((position.y - min.y) / domainSize.y) : 0.0f;
 198 }
 199
 200 /**
 201  * Internal scroll domain Constraint
 202  * Generates the scroll domain of the scroll view.
 203  */
 204 void InternalScrollDomainConstraint( Vector2& scrollDomain, const PropertyInputContainer& inputs)
 205 {
 206   const Vector2& min = inputs[0]->GetVector2();
 207   const Vector2& max = inputs[1]->GetVector2();
 208   const Vector3& size = inputs[2]->GetVector3();
 209
 210   scrollDomain = (max - min) - size.GetVectorXY();
 211 }
 212
 213 /**
 214  * Internal maximum scroll position Constraint
 215  * Generates the maximum scroll position of the scroll view.
 216  */
 217 void InternalPrePositionMaxConstraint( Vector2& scrollMax, const PropertyInputContainer& inputs)
 218 {
 219   const Vector2& max = inputs[0]->GetVector2();
 220   const Vector3& size = inputs[1]->GetVector3();
 221
 222   scrollMax = max - size.GetVectorXY();
 223 }
 224
 225 } // unnamed namespace
 226
 227 namespace Dali
 228 {
 229
 230 namespace Toolkit
 231 {
 232
 233 namespace Internal
 234 {
 235
 236 namespace
 237 {
 238
 239 BaseHandle Create()
 240 {
 241   return Toolkit::ScrollView::New();
 242 }
 243
 244 // Setup properties, signals and actions using the type-registry.
 245 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ScrollView, Toolkit::Scrollable, Create )
 246
 247 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollView, "wrapEnabled",                BOOLEAN,   WRAP_ENABLED                )
 248 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollView, "panningEnabled",             BOOLEAN,   PANNING_ENABLED             )
 249 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollView, "axisAutoLockEnabled",        BOOLEAN,   AXIS_AUTO_LOCK_ENABLED      )
 250 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollView, "wheelScrollDistanceStep",    VECTOR2,   WHEEL_SCROLL_DISTANCE_STEP  )
 251
 252 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPosition",  VECTOR2, SCROLL_POSITION)
 253 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPrePosition",   VECTOR2, SCROLL_PRE_POSITION)
 254 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionX",    SCROLL_PRE_POSITION_X, SCROLL_PRE_POSITION, 0)
 255 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionY",    SCROLL_PRE_POSITION_Y, SCROLL_PRE_POSITION, 1)
 256 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionMax",    VECTOR2, SCROLL_PRE_POSITION_MAX)
 257 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionMaxX",     SCROLL_PRE_POSITION_MAX_X, SCROLL_PRE_POSITION_MAX, 0)
 258 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollPrePositionMaxY",     SCROLL_PRE_POSITION_MAX_Y, SCROLL_PRE_POSITION_MAX, 1)
 259 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "overshootX",  FLOAT, OVERSHOOT_X)
 260 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "overshootY",  FLOAT, OVERSHOOT_Y)
 261 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollFinal",  VECTOR2, SCROLL_FINAL)
 262 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollFinalX",   SCROLL_FINAL_X, SCROLL_FINAL,0)
 263 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollFinalY",   SCROLL_FINAL_Y, SCROLL_FINAL,1)
 264 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "wrap", BOOLEAN, WRAP)
 265 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "panning", BOOLEAN, PANNING)
 266 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrolling", BOOLEAN, SCROLLING)
 267 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollDomainSize",   VECTOR2, SCROLL_DOMAIN_SIZE)
 268 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollDomainSizeX",    SCROLL_DOMAIN_SIZE_X, SCROLL_DOMAIN_SIZE, 0)
 269 DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( Toolkit, ScrollView, "scrollDomainSizeY",    SCROLL_DOMAIN_SIZE_Y, SCROLL_DOMAIN_SIZE, 1)
 270 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollDomainOffset",   VECTOR2, SCROLL_DOMAIN_OFFSET)
 271 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "scrollPositionDelta",   VECTOR2, SCROLL_POSITION_DELTA)
 272 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, ScrollView, "startPagePosition",   VECTOR3, START_PAGE_POSITION)
 273
 274 DALI_SIGNAL_REGISTRATION( Toolkit, ScrollView, "valueChanged",  SIGNAL_SNAP_STARTED )
 275
 276 DALI_TYPE_REGISTRATION_END()
 277
 278 /**
 279  * Returns whether to lock scrolling to a particular axis
 280  *
 281  * @param[in] panDelta Distance panned since gesture started
 282  * @param[in] currentLockAxis The current lock axis value
 283  * @param[in] lockGradient How quickly to lock to a particular axis
 284  *
 285  * @return The new axis lock state
 286  */
 287 ScrollView::LockAxis GetLockAxis(const Vector2& panDelta, ScrollView::LockAxis currentLockAxis, float lockGradient)
 288 {
 289   if(panDelta.LengthSquared() > AUTOLOCK_AXIS_MINIMUM_DISTANCE2 &&
 290       currentLockAxis == ScrollView::LockPossible)
 291   {
 292     float dx = fabsf(panDelta.x);
 293     float dy = fabsf(panDelta.y);
 294     if(dx * lockGradient >= dy)
 295     {
 296       // 0.36:1 gradient to the horizontal (deviate < 20 degrees)
 297       currentLockAxis = ScrollView::LockVertical;
 298     }
 299     else if(dy * lockGradient > dx)
 300     {
 301       // 0.36:1 gradient to the vertical (deviate < 20 degrees)
 302       currentLockAxis = ScrollView::LockHorizontal;
 303     }
 304     else
 305     {
 306       currentLockAxis = ScrollView::LockNone;
 307     }
 308   }
 309   return currentLockAxis;
 310 }
 311
 312 /**
 313  * Internal Pre-Position Property Constraint.
 314  *
 315  * Generates position property based on current position + gesture displacement.
 316  * Or generates position property based on positionX/Y.
 317  * Note: This is the position prior to any clamping at scroll boundaries.
 318  */
 319 struct InternalPrePositionConstraint
 320 {
 321   InternalPrePositionConstraint( const Vector2& initialPanPosition,
 322                                  const Vector2& initialPanMask,
 323                                  bool axisAutoLock,
 324                                  float axisAutoLockGradient,
 325                                  ScrollView::LockAxis initialLockAxis,
 326                                  const Vector2& maxOvershoot,
 327                                  const RulerPtr& rulerX, const RulerPtr& rulerY )
 328   : mLocalStart( initialPanPosition ),
 329     mInitialPanMask( initialPanMask ),
 330     mMaxOvershoot( maxOvershoot ),
 331     mAxisAutoLockGradient( axisAutoLockGradient ),
 332     mLockAxis( initialLockAxis ),
 333     mAxisAutoLock( axisAutoLock ),
 334     mWasPanning( false )
 335   {
 336     const RulerDomain& rulerDomainX = rulerX->GetDomain();
 337     const RulerDomain& rulerDomainY = rulerY->GetDomain();
 338     mDomainMin = Vector2( rulerDomainX.min, -rulerDomainY.min );
 339     mDomainMax = Vector2( -rulerDomainX.max, -rulerDomainY.max );
 340     mClampX = rulerDomainX.enabled;
 341     mClampY = rulerDomainY.enabled;
 342     mFixedRulerX = rulerX->GetType() == Ruler::Fixed;
 343     mFixedRulerY = rulerY->GetType() == Ruler::Fixed;
 344   }
 345
 346   void operator()( Vector2& scrollPostPosition, const PropertyInputContainer& inputs )
 347   {
 348     const Vector2& panPosition = inputs[0]->GetVector2();
 349     const bool& inGesture = inputs[1]->GetBoolean();
 350
 351     // First check if we are within a gesture.
 352     // The ScrollView may have received a start gesture from ::OnPan()
 353     // while the finish gesture is received now in this constraint.
 354     // This gesture must then be rejected as the value will be "old".
 355     // Typically the last value from the end of the last gesture.
 356     // If we are rejecting the gesture, we simply don't modify the constraint target.
 357     if( inGesture )
 358     {
 359       if( !mWasPanning )
 360       {
 361         mPrePosition = scrollPostPosition;
 362         mStartPosition = mPrePosition;
 363         mCurrentPanMask = mInitialPanMask;
 364         mWasPanning = true;
 365       }
 366
 367       // Calculate Deltas...
 368       const Vector2& currentPosition = panPosition;
 369       Vector2 panDelta( currentPosition - mLocalStart );
 370
 371       // Axis Auto Lock - locks the panning to the horizontal or vertical axis if the pan
 372       // appears mostly horizontal or mostly vertical respectively...
 373       if( mAxisAutoLock )
 374       {
 375         mLockAxis = GetLockAxis( panDelta, mLockAxis, mAxisAutoLockGradient );
 376         if( mLockAxis == ScrollView::LockVertical )
 377         {
 378           mCurrentPanMask.y = 0.0f;
 379         }
 380         else if( mLockAxis == ScrollView::LockHorizontal )
 381         {
 382           mCurrentPanMask.x = 0.0f;
 383         }
 384       }
 385
 386       // Restrict deltas based on ruler enable/disable and axis-lock state...
 387       panDelta *= mCurrentPanMask;
 388
 389       // Perform Position transform based on input deltas...
 390       scrollPostPosition = mPrePosition;
 391       scrollPostPosition += panDelta;
 392
 393       // if no wrapping then clamp preposition to maximum overshoot amount
 394       const Vector3& size = inputs[2]->GetVector3();
 395       if( mClampX )
 396       {
 397         float newXPosition = Clamp( scrollPostPosition.x, ( mDomainMax.x + size.x ) - mMaxOvershoot.x, mDomainMin.x + mMaxOvershoot.x );
 398         if( (newXPosition < scrollPostPosition.x - Math::MACHINE_EPSILON_1)
 399           || (newXPosition > scrollPostPosition.x + Math::MACHINE_EPSILON_1) )
 400         {
 401           mPrePosition.x = newXPosition;
 402           mLocalStart.x = panPosition.x;
 403         }
 404         scrollPostPosition.x = newXPosition;
 405       }
 406       if( mClampY )
 407       {
 408         float newYPosition = Clamp( scrollPostPosition.y, ( mDomainMax.y + size.y ) - mMaxOvershoot.y, mDomainMin.y + mMaxOvershoot.y );
 409         if( ( newYPosition < scrollPostPosition.y - Math::MACHINE_EPSILON_1 )
 410           || ( newYPosition > scrollPostPosition.y + Math::MACHINE_EPSILON_1 ) )
 411         {
 412           mPrePosition.y = newYPosition;
 413           mLocalStart.y = panPosition.y;
 414         }
 415         scrollPostPosition.y = newYPosition;
 416       }
 417
 418       // If we are using a fixed ruler in a particular axis, limit the maximum pages scrolled on that axis.
 419       if( mFixedRulerX || mFixedRulerY )
 420       {
 421         // Here we limit the maximum amount that can be moved from the starting position of the gesture to one page.
 422         // We do this only if we have a fixed ruler (on that axis) and the mode is enabled.
 423         // Note: 1.0f is subtracted to keep the value within one page size (otherwise we stray on to the page after).
 424         // Note: A further 1.0f is subtracted to handle a compensation that happens later within the flick handling code in SnapWithVelocity().
 425         //       When a flick is completed, an adjustment of 1.0f is sometimes made to allow for the scenario where:
 426         //       A flick finishes before the update thread has advanced the scroll position past the previous snap point.
 427         Vector2 pageSizeLimit( size.x - ( 1.0f + 1.0f ), size.y - ( 1.0f - 1.0f ) );
 428         Vector2 minPosition( mStartPosition.x - pageSizeLimit.x, mStartPosition.y - pageSizeLimit.y );
 429         Vector2 maxPosition( mStartPosition.x + pageSizeLimit.x, mStartPosition.y + pageSizeLimit.y );
 430
 431         if( mFixedRulerX )
 432         {
 433           scrollPostPosition.x = Clamp( scrollPostPosition.x, minPosition.x, maxPosition.x );
 434         }
 435         if( mFixedRulerY )
 436         {
 437           scrollPostPosition.y = Clamp( scrollPostPosition.y, minPosition.y, maxPosition.y );
 438         }
 439       }
 440     }
 441   }
 442
 443   Vector2 mPrePosition;
 444   Vector2 mLocalStart;
 445   Vector2 mStartPosition;               ///< The start position of the gesture - used to limit scroll amount (not modified by clamping).
 446   Vector2 mInitialPanMask;              ///< Initial pan mask (based on ruler settings).
 447   Vector2 mCurrentPanMask;              ///< Current pan mask that can be altered by axis lock mode.
 448   Vector2 mDomainMin;
 449   Vector2 mDomainMax;
 450   Vector2 mMaxOvershoot;
 451
 452   float mAxisAutoLockGradient;          ///< Set by ScrollView
 453   ScrollView::LockAxis mLockAxis;
 454
 455   bool mAxisAutoLock:1;                 ///< Set by ScrollView
 456   bool mWasPanning:1;
 457   bool mClampX:1;
 458   bool mClampY:1;
 459   bool mFixedRulerX:1;
 460   bool mFixedRulerY:1;
 461 };
 462
 463 /**
 464  * Internal Position Property Constraint.
 465  *
 466  * Generates position property based on pre-position
 467  * Note: This is the position after clamping.
 468  * (uses result of InternalPrePositionConstraint)
 469  */
 470 struct InternalPositionConstraint
 471 {
 472   InternalPositionConstraint(const RulerDomain& domainX, const RulerDomain& domainY, bool wrap)
 473   : mDomainMin( -domainX.min, -domainY.min ),
 474     mDomainMax( -domainX.max, -domainY.max ),
 475     mClampX( domainX.enabled ),
 476     mClampY( domainY.enabled ),
 477     mWrap( wrap )
 478   {
 479   }
 480
 481   void operator()( Vector2& position, const PropertyInputContainer& inputs )
 482   {
 483     position = inputs[0]->GetVector2();
 484     const Vector2& size = inputs[3]->GetVector3().GetVectorXY();
 485     const Vector2& min = inputs[1]->GetVector2();
 486     const Vector2& max = inputs[2]->GetVector2();
 487
 488     if( mWrap )
 489     {
 490       position.x = -WrapInDomain(-position.x, min.x, max.x);
 491       position.y = -WrapInDomain(-position.y, min.y, max.y);
 492     }
 493     else
 494     {
 495       // clamp post position to domain
 496       position.x = mClampX ? Clamp(position.x, mDomainMax.x + size.x, mDomainMin.x ) : position.x;
 497       position.y = mClampY ? Clamp(position.y, mDomainMax.y + size.y, mDomainMin.y ) : position.y;
 498     }
 499   }
 500
 501   Vector2 mDomainMin;
 502   Vector2 mDomainMax;
 503   bool mClampX;
 504   bool mClampY;
 505   bool mWrap;
 506
 507 };
 508
 509 /**
 510  * This constraint updates the X overshoot property using the difference
 511  * SCROLL_PRE_POSITION.x and SCROLL_POSITION.x, returning a relative value between 0.0f and 1.0f
 512  */
 513 struct OvershootXConstraint
 514 {
 515   OvershootXConstraint(float maxOvershoot) : mMaxOvershoot(maxOvershoot) {}
 516
 517   void operator()( float& current, const PropertyInputContainer& inputs )
 518   {
 519     if( inputs[2]->GetBoolean() )
 520     {
 521       const Vector2& scrollPrePosition = inputs[0]->GetVector2();
 522       const Vector2& scrollPostPosition = inputs[1]->GetVector2();
 523       float newOvershoot = scrollPrePosition.x - scrollPostPosition.x;
 524       current = (newOvershoot > 0.0f ? std::min(newOvershoot, mMaxOvershoot) : std::max(newOvershoot, -mMaxOvershoot)) / mMaxOvershoot;
 525     }
 526     else
 527     {
 528       current = 0.0f;
 529     }
 530   }
 531
 532   float mMaxOvershoot;
 533 };
 534
 535 /**
 536  * This constraint updates the Y overshoot property using the difference
 537  * SCROLL_PRE_POSITION.y and SCROLL_POSITION.y, returning a relative value between 0.0f and 1.0f
 538  */
 539 struct OvershootYConstraint
 540 {
 541   OvershootYConstraint(float maxOvershoot) : mMaxOvershoot(maxOvershoot) {}
 542
 543   void operator()( float& current, const PropertyInputContainer& inputs )
 544   {
 545     if( inputs[2]->GetBoolean() )
 546     {
 547       const Vector2& scrollPrePosition = inputs[0]->GetVector2();
 548       const Vector2& scrollPostPosition = inputs[1]->GetVector2();
 549       float newOvershoot = scrollPrePosition.y - scrollPostPosition.y;
 550       current = (newOvershoot > 0.0f ? std::min(newOvershoot, mMaxOvershoot) : std::max(newOvershoot, -mMaxOvershoot)) / mMaxOvershoot;
 551     }
 552     else
 553     {
 554       current = 0.0f;
 555     }
 556   }
 557
 558   float mMaxOvershoot;
 559 };
 560
 561 /**
 562  * Internal Position-Delta Property Constraint.
 563  *
 564  * Generates position-delta property based on scroll-position + scroll-offset properties.
 565  */
 566 void InternalPositionDeltaConstraint( Vector2& current, const PropertyInputContainer& inputs )
 567 {
 568   const Vector2& scrollPosition = inputs[0]->GetVector2();
 569   const Vector2& scrollOffset = inputs[1]->GetVector2();
 570
 571   current = scrollPosition + scrollOffset;
 572 }
 573
 574 /**
 575  * Internal Final Position Constraint
 576  * The position of content is:
 577  * of scroll-position + f(scroll-overshoot)
 578  * where f(...) function defines how overshoot
 579  * should affect final-position.
 580  */
 581 struct InternalFinalConstraint
 582 {
 583   InternalFinalConstraint(AlphaFunctionPrototype functionX,
 584                           AlphaFunctionPrototype functionY)
 585   : mFunctionX(functionX),
 586     mFunctionY(functionY)
 587   {
 588   }
 589
 590   void operator()( Vector2& current, const PropertyInputContainer& inputs )
 591   {
 592     const float& overshootx = inputs[1]->GetFloat();
 593     const float& overshooty = inputs[2]->GetFloat();
 594     Vector2 offset( mFunctionX(overshootx),
 595                     mFunctionY(overshooty) );
 596
 597     current = inputs[0]->GetVector2() - offset;
 598   }
 599
 600   AlphaFunctionPrototype mFunctionX;
 601   AlphaFunctionPrototype mFunctionY;
 602 };
 603
 604 }
 605
 606
 607 ///////////////////////////////////////////////////////////////////////////////////////////////////
 608 // ScrollView
 609 ///////////////////////////////////////////////////////////////////////////////////////////////////
 610
 611 Dali::Toolkit::ScrollView ScrollView::New()
 612 {
 613   // Create the implementation
 614   ScrollViewPtr scrollView(new ScrollView());
 615
 616   // Pass ownership to CustomActor via derived handle
 617   Dali::Toolkit::ScrollView handle(*scrollView);
 618
 619   // Second-phase init of the implementation
 620   // This can only be done after the CustomActor connection has been made...
 621   scrollView->Initialize();
 622
 623   return handle;
 624 }
 625
 626 ScrollView::ScrollView()
 627 : ScrollBase( ControlBehaviour( REQUIRES_WHEEL_EVENTS ) ),   // Enable size negotiation
 628   mTouchDownTime(0u),
 629   mGestureStackDepth(0),
 630   mScrollStateFlags(0),
 631   mLockAxis(LockPossible),
 632   mScrollUpdateDistance(DEFAULT_SCROLL_UPDATE_DISTANCE),
 633   mMaxOvershoot(DEFAULT_MAX_OVERSHOOT, DEFAULT_MAX_OVERSHOOT),
 634   mUserMaxOvershoot(DEFAULT_MAX_OVERSHOOT, DEFAULT_MAX_OVERSHOOT),
 635   mSnapOvershootDuration(DEFAULT_SNAP_OVERSHOOT_DURATION),
 636   mSnapOvershootAlphaFunction(AlphaFunction::EASE_OUT),
 637   mSnapDuration(DEFAULT_SLOW_SNAP_ANIMATION_DURATION),
 638   mSnapAlphaFunction(AlphaFunction::EASE_OUT),
 639   mMinFlickDistance(DEFAULT_MIN_FLICK_DISTANCE),
 640   mFlickSpeedThreshold(DEFAULT_MIN_FLICK_SPEED_THRESHOLD),
 641   mFlickDuration(DEFAULT_FAST_SNAP_ANIMATION_DURATION),
 642   mFlickAlphaFunction(AlphaFunction::EASE_OUT),
 643   mAxisAutoLockGradient(DEFAULT_AXIS_AUTO_LOCK_GRADIENT),
 644   mFrictionCoefficient(DEFAULT_FRICTION_COEFFICIENT),
 645   mFlickSpeedCoefficient(DEFAULT_FLICK_SPEED_COEFFICIENT),
 646   mMaxFlickSpeed(DEFAULT_MAX_FLICK_SPEED),
 647   mWheelScrollDistanceStep(Vector2::ZERO),
 648   mInAccessibilityPan(false),
 649   mScrolling(false),
 650   mScrollInterrupted(false),
 651   mPanning(false),
 652   mSensitive(true),
 653   mTouchDownTimeoutReached(false),
 654   mActorAutoSnapEnabled(false),
 655   mAutoResizeContainerEnabled(false),
 656   mWrapMode(false),
 657   mAxisAutoLock(false),
 658   mAlterChild(false),
 659   mDefaultMaxOvershoot(true),
 660   mCanScrollHorizontal(true),
 661   mCanScrollVertical(true)
 662 {
 663 }
 664
 665 void ScrollView::OnInitialize()
 666 {
 667   Actor self = Self();
 668
 669   // Internal Actor, used to hide actors from enumerations.
 670   // Also actors added to Internal actor appear as overlays e.g. ScrollBar components.
 671   mInternalActor = Actor::New();
 672   self.Add(mInternalActor);
 673
 674   mInternalActor.SetParentOrigin(ParentOrigin::CENTER);
 675   mInternalActor.SetAnchorPoint(AnchorPoint::CENTER);
 676   mInternalActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
 677
 678   mAlterChild = true;
 679
 680   mScrollPostPosition = mScrollPrePosition = Vector2::ZERO;
 681
 682   mWheelScrollDistanceStep = Stage::GetCurrent().GetSize() * DEFAULT_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION;
 683
 684   mGestureStackDepth = 0;
 685
 686   self.TouchSignal().Connect( this, &ScrollView::OnTouch );
 687   EnableGestureDetection( Gesture::Type( Gesture::Pan ) );
 688
 689   // By default we'll allow the user to freely drag the scroll view,
 690   // while disabling the other rulers.
 691   RulerPtr ruler = new DefaultRuler();
 692   mRulerX = ruler;
 693   mRulerY = ruler;
 694
 695   self.SetProperty(Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL, mCanScrollVertical);
 696   self.SetProperty(Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL, mCanScrollHorizontal);
 697
 698   UpdatePropertyDomain();
 699   SetInternalConstraints();
 700 }
 701
 702 void ScrollView::OnStageConnection( int depth )
 703 {
 704   ScrollBase::OnStageConnection( depth );
 705
 706   DALI_LOG_SCROLL_STATE("[0x%X]", this);
 707
 708   if ( mSensitive )
 709   {
 710     SetScrollSensitive( false );
 711     SetScrollSensitive( true );
 712   }
 713   if(IsOvershootEnabled())
 714   {
 715     // try and make sure property notifications are set
 716     EnableScrollOvershoot(true);
 717   }
 718 }
 719
 720 void ScrollView::OnStageDisconnection()
 721 {
 722   DALI_LOG_SCROLL_STATE("[0x%X]", this);
 723
 724   StopAnimation();
 725
 726   ScrollBase::OnStageDisconnection();
 727 }
 728
 729 ScrollView::~ScrollView()
 730 {
 731   DALI_LOG_SCROLL_STATE("[0x%X]", this);
 732 }
 733
 734 AlphaFunction ScrollView::GetScrollSnapAlphaFunction() const
 735 {
 736   return mSnapAlphaFunction;
 737 }
 738
 739 void ScrollView::SetScrollSnapAlphaFunction(AlphaFunction alpha)
 740 {
 741   mSnapAlphaFunction = alpha;
 742 }
 743
 744 AlphaFunction ScrollView::GetScrollFlickAlphaFunction() const
 745 {
 746   return mFlickAlphaFunction;
 747 }
 748
 749 void ScrollView::SetScrollFlickAlphaFunction(AlphaFunction alpha)
 750 {
 751   mFlickAlphaFunction = alpha;
 752 }
 753
 754 float ScrollView::GetScrollSnapDuration() const
 755 {
 756   return mSnapDuration;
 757 }
 758
 759 void ScrollView::SetScrollSnapDuration(float time)
 760 {
 761   mSnapDuration = time;
 762 }
 763
 764 float ScrollView::GetScrollFlickDuration() const
 765 {
 766   return mFlickDuration;
 767 }
 768
 769 void ScrollView::SetScrollFlickDuration(float time)
 770 {
 771   mFlickDuration = time;
 772 }
 773
 774 void ScrollView::ApplyEffect(Toolkit::ScrollViewEffect effect)
 775 {
 776   Dali::Toolkit::ScrollView self = Dali::Toolkit::ScrollView::DownCast(Self());
 777
 778   // Assertion check to ensure effect doesn't already exist in this scrollview
 779   bool effectAlreadyExistsInScrollView(false);
 780   for (ScrollViewEffectIter iter = mEffects.begin(); iter != mEffects.end(); ++iter)
 781   {
 782     if(*iter==effect)
 783     {
 784       effectAlreadyExistsInScrollView = true;
 785       break;
 786     }
 787   }
 788
 789   DALI_ASSERT_ALWAYS(!effectAlreadyExistsInScrollView);
 790
 791   // add effect to effects list
 792   mEffects.push_back(effect);
 793
 794   // invoke Attachment request to ScrollView first
 795   GetImpl(effect).Attach(self);
 796 }
 797
 798 void ScrollView::RemoveEffect(Toolkit::ScrollViewEffect effect)
 799 {
 800   Dali::Toolkit::ScrollView self = Dali::Toolkit::ScrollView::DownCast(Self());
 801
 802   // remove effect from effects list
 803   bool effectExistedInScrollView(false);
 804   for (ScrollViewEffectIter iter = mEffects.begin(); iter != mEffects.end(); ++iter)
 805   {
 806     if(*iter==effect)
 807     {
 808       mEffects.erase(iter);
 809       effectExistedInScrollView = true;
 810       break;
 811     }
 812   }
 813
 814   // Assertion check to ensure effect existed.
 815   DALI_ASSERT_ALWAYS(effectExistedInScrollView);
 816
 817   // invoke Detachment request to ScrollView last
 818   GetImpl(effect).Detach(self);
 819 }
 820
 821 void ScrollView::RemoveAllEffects()
 822 {
 823   Dali::Toolkit::ScrollView self = Dali::Toolkit::ScrollView::DownCast(Self());
 824
 825   for (ScrollViewEffectIter effectIter = mEffects.begin(); effectIter != mEffects.end(); ++effectIter)
 826   {
 827     Toolkit::ScrollViewEffect effect = *effectIter;
 828
 829     // invoke Detachment request to ScrollView last
 830     GetImpl(effect).Detach(self);
 831   }
 832
 833   mEffects.clear();
 834 }
 835
 836 void ScrollView::ApplyConstraintToChildren(Constraint constraint)
 837 {
 838   ApplyConstraintToBoundActors(constraint);
 839 }
 840
 841 void ScrollView::RemoveConstraintsFromChildren()
 842 {
 843   RemoveConstraintsFromBoundActors();
 844 }
 845
 846 const RulerPtr ScrollView::GetRulerX() const
 847 {
 848   return mRulerX;
 849 }
 850
 851 const RulerPtr ScrollView::GetRulerY() const
 852 {
 853   return mRulerY;
 854 }
 855
 856 void ScrollView::SetRulerX(RulerPtr ruler)
 857 {
 858   mRulerX = ruler;
 859
 860   UpdatePropertyDomain();
 861   UpdateMainInternalConstraint();
 862 }
 863
 864 void ScrollView::SetRulerY(RulerPtr ruler)
 865 {
 866   mRulerY = ruler;
 867
 868   UpdatePropertyDomain();
 869   UpdateMainInternalConstraint();
 870 }
 871
 872 void ScrollView::UpdatePropertyDomain()
 873 {
 874   Actor self = Self();
 875   Vector3 size = self.GetTargetSize();
 876   Vector2 min = mMinScroll;
 877   Vector2 max = mMaxScroll;
 878   bool scrollPositionChanged = false;
 879   bool domainChanged = false;
 880
 881   bool canScrollVertical = false;
 882   bool canScrollHorizontal = false;
 883   UpdateLocalScrollProperties();
 884   if(mRulerX->IsEnabled())
 885   {
 886     const Toolkit::RulerDomain& rulerDomain = mRulerX->GetDomain();
 887     if( fabsf(min.x - rulerDomain.min) > Math::MACHINE_EPSILON_100
 888         || fabsf(max.x - rulerDomain.max) > Math::MACHINE_EPSILON_100 )
 889     {
 890       domainChanged = true;
 891       min.x = rulerDomain.min;
 892       max.x = rulerDomain.max;
 893
 894       // make sure new scroll value is within new domain
 895       if( mScrollPrePosition.x < min.x
 896           || mScrollPrePosition.x > max.x )
 897       {
 898         scrollPositionChanged = true;
 899         mScrollPrePosition.x = Clamp(mScrollPrePosition.x, -(max.x - size.x), -min.x);
 900       }
 901     }
 902     if( (fabsf(rulerDomain.max - rulerDomain.min) - size.x) > Math::MACHINE_EPSILON_100 )
 903     {
 904       canScrollHorizontal = true;
 905     }
 906   }
 907   else if( fabs(min.x) > Math::MACHINE_EPSILON_100
 908            || fabs(max.x) > Math::MACHINE_EPSILON_100 )
 909   {
 910     // need to reset to 0
 911     domainChanged = true;
 912     min.x = 0.0f;
 913     max.x = 0.0f;
 914     canScrollHorizontal = false;
 915   }
 916
 917   if(mRulerY->IsEnabled())
 918   {
 919     const Toolkit::RulerDomain& rulerDomain = mRulerY->GetDomain();
 920     if( fabsf(min.y - rulerDomain.min) > Math::MACHINE_EPSILON_100
 921         || fabsf(max.y - rulerDomain.max) > Math::MACHINE_EPSILON_100 )
 922     {
 923       domainChanged = true;
 924       min.y = rulerDomain.min;
 925       max.y = rulerDomain.max;
 926
 927       // make sure new scroll value is within new domain
 928       if( mScrollPrePosition.y < min.y
 929           || mScrollPrePosition.y > max.y )
 930       {
 931         scrollPositionChanged = true;
 932         mScrollPrePosition.y = Clamp(mScrollPrePosition.y, -(max.y - size.y), -min.y);
 933       }
 934     }
 935     if( (fabsf(rulerDomain.max - rulerDomain.min) - size.y) > Math::MACHINE_EPSILON_100 )
 936     {
 937       canScrollVertical = true;
 938     }
 939   }
 940   else if( fabs(min.y) > Math::MACHINE_EPSILON_100
 941            || fabs(max.y) > Math::MACHINE_EPSILON_100 )
 942   {
 943     // need to reset to 0
 944     domainChanged = true;
 945     min.y = 0.0f;
 946     max.y = 0.0f;
 947     canScrollVertical = false;
 948   }
 949
 950   // avoid setting properties if possible, otherwise this will cause an entire update as well as triggering constraints using each property we update
 951   if( mCanScrollVertical != canScrollVertical )
 952   {
 953     mCanScrollVertical = canScrollVertical;
 954     self.SetProperty(Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL, canScrollVertical);
 955   }
 956   if( mCanScrollHorizontal != canScrollHorizontal )
 957   {
 958     mCanScrollHorizontal = canScrollHorizontal;
 959     self.SetProperty(Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL, canScrollHorizontal);
 960   }
 961   if( scrollPositionChanged )
 962   {
 963     DALI_LOG_SCROLL_STATE("[0x%X] Domain Changed, setting SCROLL_PRE_POSITION To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
 964     self.SetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, mScrollPrePosition);
 965   }
 966   if( domainChanged )
 967   {
 968     mMinScroll = min;
 969     mMaxScroll = max;
 970     self.SetProperty(Toolkit::Scrollable::Property::SCROLL_POSITION_MIN, mMinScroll );
 971     self.SetProperty(Toolkit::Scrollable::Property::SCROLL_POSITION_MAX, mMaxScroll );
 972   }
 973 }
 974
 975 bool ScrollView::GetScrollSensitive()
 976 {
 977   return mSensitive;
 978 }
 979
 980 void ScrollView::SetScrollSensitive(bool sensitive)
 981 {
 982   Actor self = Self();
 983   PanGestureDetector panGesture( GetPanGestureDetector() );
 984
 985   DALI_LOG_SCROLL_STATE("[0x%X] sensitive: before:[%d] setting[%d]", this, int(mSensitive), int(sensitive));
 986
 987   if((!mSensitive) && (sensitive))
 988   {
 989     mSensitive = sensitive;
 990     panGesture.Attach(self);
 991   }
 992   else if((mSensitive) && (!sensitive))
 993   {
 994     DALI_LOG_SCROLL_STATE("[0x%X] BEFORE: panning:[%d]", this, int(mPanning));
 995
 996     // while the scroll view is panning, the state needs to be reset.
 997     if ( mPanning )
 998     {
 999       PanGesture cancelGesture( Gesture::Cancelled );
1000       OnPan( cancelGesture );
1001     }
1002
1003     panGesture.Detach(self);
1004     mSensitive = sensitive;
1005
1006     mGestureStackDepth = 0;
1007     DALI_LOG_SCROLL_STATE("[0x%X] AFTER: panning:[%d]", this, int(mPanning));
1008   }
1009 }
1010
1011 void ScrollView::SetMaxOvershoot(float overshootX, float overshootY)
1012 {
1013   mMaxOvershoot.x = overshootX;
1014   mMaxOvershoot.y = overshootY;
1015   mUserMaxOvershoot = mMaxOvershoot;
1016   mDefaultMaxOvershoot = false;
1017   UpdateMainInternalConstraint();
1018 }
1019
1020 void ScrollView::SetSnapOvershootAlphaFunction(AlphaFunction alpha)
1021 {
1022   mSnapOvershootAlphaFunction = alpha;
1023 }
1024
1025 float ScrollView::GetSnapOvershootDuration()
1026 {
1027   return mSnapOvershootDuration;
1028 }
1029
1030 void ScrollView::SetSnapOvershootDuration(float duration)
1031 {
1032   mSnapOvershootDuration = duration;
1033 }
1034
1035 bool ScrollView::GetActorAutoSnap()
1036 {
1037   return mActorAutoSnapEnabled;
1038 }
1039
1040 void ScrollView::SetActorAutoSnap(bool enable)
1041 {
1042   mActorAutoSnapEnabled = enable;
1043 }
1044
1045 void ScrollView::SetAutoResize(bool enable)
1046 {
1047   mAutoResizeContainerEnabled = enable;
1048   // TODO: This needs a lot of issues to be addressed before working.
1049 }
1050
1051 bool ScrollView::GetWrapMode() const
1052 {
1053   return mWrapMode;
1054 }
1055
1056 void ScrollView::SetWrapMode(bool enable)
1057 {
1058   mWrapMode = enable;
1059   Self().SetProperty(Toolkit::ScrollView::Property::WRAP, enable);
1060 }
1061
1062 int ScrollView::GetScrollUpdateDistance() const
1063 {
1064   return mScrollUpdateDistance;
1065 }
1066
1067 void ScrollView::SetScrollUpdateDistance(int distance)
1068 {
1069   mScrollUpdateDistance = distance;
1070 }
1071
1072 bool ScrollView::GetAxisAutoLock() const
1073 {
1074   return mAxisAutoLock;
1075 }
1076
1077 void ScrollView::SetAxisAutoLock(bool enable)
1078 {
1079   mAxisAutoLock = enable;
1080   UpdateMainInternalConstraint();
1081 }
1082
1083 float ScrollView::GetAxisAutoLockGradient() const
1084 {
1085   return mAxisAutoLockGradient;
1086 }
1087
1088 void ScrollView::SetAxisAutoLockGradient(float gradient)
1089 {
1090   DALI_ASSERT_DEBUG( gradient >= 0.0f && gradient <= 1.0f );
1091   mAxisAutoLockGradient = gradient;
1092   UpdateMainInternalConstraint();
1093 }
1094
1095 float ScrollView::GetFrictionCoefficient() const
1096 {
1097   return mFrictionCoefficient;
1098 }
1099
1100 void ScrollView::SetFrictionCoefficient(float friction)
1101 {
1102   DALI_ASSERT_DEBUG( friction > 0.0f );
1103   mFrictionCoefficient = friction;
1104 }
1105
1106 float ScrollView::GetFlickSpeedCoefficient() const
1107 {
1108   return mFlickSpeedCoefficient;
1109 }
1110
1111 void ScrollView::SetFlickSpeedCoefficient(float speed)
1112 {
1113   mFlickSpeedCoefficient = speed;
1114 }
1115
1116 Vector2 ScrollView::GetMinimumDistanceForFlick() const
1117 {
1118   return mMinFlickDistance;
1119 }
1120
1121 void ScrollView::SetMinimumDistanceForFlick( const Vector2& distance )
1122 {
1123   mMinFlickDistance = distance;
1124 }
1125
1126 float ScrollView::GetMinimumSpeedForFlick() const
1127 {
1128   return mFlickSpeedThreshold;
1129 }
1130
1131 void ScrollView::SetMinimumSpeedForFlick( float speed )
1132 {
1133   mFlickSpeedThreshold = speed;
1134 }
1135
1136 float ScrollView::GetMaxFlickSpeed() const
1137 {
1138   return mMaxFlickSpeed;
1139 }
1140
1141 void ScrollView::SetMaxFlickSpeed(float speed)
1142 {
1143   mMaxFlickSpeed = speed;
1144 }
1145
1146 void ScrollView::SetWheelScrollDistanceStep(Vector2 step)
1147 {
1148   mWheelScrollDistanceStep = step;
1149 }
1150
1151 Vector2 ScrollView::GetWheelScrollDistanceStep() const
1152 {
1153   return mWheelScrollDistanceStep;
1154 }
1155
1156 unsigned int ScrollView::GetCurrentPage() const
1157 {
1158   // in case animation is currently taking place.
1159   Vector2 position = GetPropertyPosition();
1160
1161   Actor self = Self();
1162   unsigned int page = 0;
1163   unsigned int pagesPerVolume = 1;
1164   unsigned int volume = 0;
1165
1166   // if rulerX is enabled, then get page count (columns)
1167   page = mRulerX->GetPageFromPosition(-position.x, mWrapMode);
1168   volume = mRulerY->GetPageFromPosition(-position.y, mWrapMode);
1169   pagesPerVolume = mRulerX->GetTotalPages();
1170
1171   return volume * pagesPerVolume + page;
1172 }
1173
1174 Vector2 ScrollView::GetCurrentScrollPosition() const
1175 {
1176   return -GetPropertyPosition();
1177 }
1178
1179 Vector2 ScrollView::GetDomainSize() const
1180 {
1181   Vector3 size = Self().GetCurrentSize();
1182
1183   const RulerDomain& xDomain = GetRulerX()->GetDomain();
1184   const RulerDomain& yDomain = GetRulerY()->GetDomain();
1185
1186   Vector2 domainSize;
1187   domainSize.x = xDomain.max - xDomain.min - size.x;
1188   domainSize.y = yDomain.max - yDomain.min - size.y;
1189   return domainSize;
1190 }
1191
1192 void ScrollView::TransformTo(const Vector2& position,
1193                              DirectionBias horizontalBias, DirectionBias verticalBias)
1194 {
1195   TransformTo(position, mSnapDuration, mSnapAlphaFunction, horizontalBias, verticalBias);
1196 }
1197
1198 void ScrollView::TransformTo(const Vector2& position, float duration, AlphaFunction alpha,
1199                              DirectionBias horizontalBias, DirectionBias verticalBias)
1200 {
1201   // If this is called while the timer is running, then cancel it
1202   StopTouchDownTimer();
1203
1204   Actor self( Self() );
1205
1206   // Guard against destruction during signal emission
1207   // Note that Emit() methods are called indirectly e.g. from within ScrollView::AnimateTo()
1208   Toolkit::ScrollView handle( GetOwner() );
1209
1210   DALI_LOG_SCROLL_STATE("[0x%X] pos[%.2f,%.2f], duration[%.2f] bias[%d, %d]",
1211     this, position.x, position.y, duration, int(horizontalBias), int(verticalBias));
1212
1213   Vector2 currentScrollPosition = GetCurrentScrollPosition();
1214   self.SetProperty( Toolkit::ScrollView::Property::START_PAGE_POSITION, Vector3(currentScrollPosition) );
1215
1216   if( mScrolling ) // are we interrupting a current scroll?
1217   {
1218     // set mScrolling to false, in case user has code that interrogates mScrolling Getter() in complete.
1219     mScrolling = false;
1220     DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
1221     mScrollCompletedSignal.Emit( currentScrollPosition );
1222   }
1223
1224   if( mPanning ) // are we interrupting a current pan?
1225   {
1226     DALI_LOG_SCROLL_STATE("[0x%X] Interrupting Pan, set to false", this );
1227     mPanning = false;
1228     mGestureStackDepth = 0;
1229     self.SetProperty( Toolkit::ScrollView::Property::PANNING, false );
1230
1231     if( mScrollMainInternalPrePositionConstraint )
1232     {
1233       mScrollMainInternalPrePositionConstraint.Remove();
1234     }
1235   }
1236
1237   self.SetProperty(Toolkit::ScrollView::Property::SCROLLING, true);
1238   mScrolling = true;
1239
1240   DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignal 1 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
1241   mScrollStartedSignal.Emit( currentScrollPosition );
1242   bool animating = AnimateTo(-position,
1243                              Vector2::ONE * duration,
1244                              alpha,
1245                              true,
1246                              horizontalBias,
1247                              verticalBias,
1248                              Snap);
1249
1250   if(!animating)
1251   {
1252     // if not animating, then this pan has completed right now.
1253     self.SetProperty(Toolkit::ScrollView::Property::SCROLLING, false);
1254     mScrolling = false;
1255
1256     // If we have no duration, then in the next update frame, we will be at the position specified as we just set.
1257     // In this scenario, we cannot return the currentScrollPosition as this is out-of-date and should instead return the requested final position
1258     Vector2 completedPosition( currentScrollPosition );
1259     if( duration <= Math::MACHINE_EPSILON_10 )
1260     {
1261       completedPosition = position;
1262     }
1263
1264     DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 2 [%.2f, %.2f]", this, completedPosition.x, completedPosition.y);
1265     SetScrollUpdateNotification(false);
1266     mScrollCompletedSignal.Emit( completedPosition );
1267   }
1268 }
1269
1270 void ScrollView::ScrollTo(const Vector2& position)
1271 {
1272   ScrollTo(position, mSnapDuration );
1273 }
1274
1275 void ScrollView::ScrollTo(const Vector2& position, float duration)
1276 {
1277   ScrollTo(position, duration, DirectionBiasNone, DirectionBiasNone);
1278 }
1279
1280 void ScrollView::ScrollTo(const Vector2& position, float duration, AlphaFunction alpha)
1281 {
1282   ScrollTo(position, duration, alpha, DirectionBiasNone, DirectionBiasNone);
1283 }
1284
1285 void ScrollView::ScrollTo(const Vector2& position, float duration,
1286                           DirectionBias horizontalBias, DirectionBias verticalBias)
1287 {
1288   ScrollTo(position, duration, mSnapAlphaFunction, horizontalBias, verticalBias);
1289 }
1290
1291 void ScrollView::ScrollTo(const Vector2& position, float duration, AlphaFunction alpha,
1292                 DirectionBias horizontalBias, DirectionBias verticalBias)
1293 {
1294   DALI_LOG_SCROLL_STATE("[0x%X] position[%.2f, %.2f] duration[%.2f], bias[%d, %d]", this, position.x, position.y, duration, int(horizontalBias), int(verticalBias));
1295   TransformTo(position, duration, alpha, horizontalBias, verticalBias);
1296 }
1297
1298 void ScrollView::ScrollTo(unsigned int page)
1299 {
1300   ScrollTo(page, mSnapDuration);
1301 }
1302
1303 void ScrollView::ScrollTo(unsigned int page, float duration, DirectionBias bias)
1304 {
1305   Vector2 position;
1306   unsigned int volume;
1307   unsigned int libraries;
1308
1309   // The position to scroll to is continuous and linear
1310   // unless a domain has been enabled on the X axis.
1311   // or if WrapMode has been enabled.
1312   bool carryX = mRulerX->GetDomain().enabled | mWrapMode;
1313   bool carryY = mRulerY->GetDomain().enabled | mWrapMode;
1314
1315   position.x = mRulerX->GetPositionFromPage(page, volume, carryX);
1316   position.y = mRulerY->GetPositionFromPage(volume, libraries, carryY);
1317
1318   ScrollTo(position, duration, bias, bias);
1319 }
1320
1321 void ScrollView::ScrollTo(Actor &actor)
1322 {
1323   ScrollTo(actor, mSnapDuration);
1324 }
1325
1326 void ScrollView::ScrollTo(Actor &actor, float duration)
1327 {
1328   DALI_ASSERT_ALWAYS(actor.GetParent() == Self());
1329
1330   Actor self = Self();
1331   Vector3 size = self.GetCurrentSize();
1332   Vector3 position = actor.GetCurrentPosition();
1333   Vector2 prePosition = GetPropertyPrePosition();
1334   position.GetVectorXY() -= prePosition;
1335
1336   ScrollTo(Vector2(position.x - size.width * 0.5f, position.y - size.height * 0.5f), duration);
1337 }
1338
1339 Actor ScrollView::FindClosestActor()
1340 {
1341   Actor self = Self();
1342   Vector3 size = self.GetCurrentSize();
1343
1344   return FindClosestActorToPosition(Vector3(size.width * 0.5f,size.height * 0.5f,0.0f));
1345 }
1346
1347 Actor ScrollView::FindClosestActorToPosition(const Vector3& position, FindDirection dirX, FindDirection dirY, FindDirection dirZ)
1348 {
1349   Actor closestChild;
1350   float closestDistance2 = 0.0f;
1351   Vector3 actualPosition = position;
1352
1353   unsigned int numChildren = Self().GetChildCount();
1354
1355   for(unsigned int i = 0; i < numChildren; ++i)
1356   {
1357     Actor child = Self().GetChildAt(i);
1358
1359     if(mInternalActor == child) // ignore internal actor.
1360     {
1361       continue;
1362     }
1363
1364     Vector3 childPosition = GetPositionOfAnchor(child, AnchorPoint::CENTER);
1365
1366     Vector3 delta = childPosition - actualPosition;
1367
1368     // X-axis checking (only find Actors to the [dirX] of actualPosition)
1369     if(dirX > All) // != All,None
1370     {
1371       FindDirection deltaH = delta.x > 0 ? Right : Left;
1372       if(dirX != deltaH)
1373       {
1374         continue;
1375       }
1376     }
1377
1378     // Y-axis checking (only find Actors to the [dirY] of actualPosition)
1379     if(dirY > All) // != All,None
1380     {
1381       FindDirection deltaV = delta.y > 0 ? Down : Up;
1382       if(dirY  != deltaV)
1383       {
1384         continue;
1385       }
1386     }
1387
1388     // Z-axis checking (only find Actors to the [dirZ] of actualPosition)
1389     if(dirZ > All) // != All,None
1390     {
1391       FindDirection deltaV = delta.y > 0 ? In : Out;
1392       if(dirZ  != deltaV)
1393       {
1394         continue;
1395       }
1396     }
1397
1398     // compare child to closest child in terms of distance.
1399     float distance2 = 0.0f;
1400
1401     // distance2 = the Square of the relevant dimensions of delta
1402     if(dirX != None)
1403     {
1404       distance2 += delta.x * delta.x;
1405     }
1406
1407     if(dirY != None)
1408     {
1409       distance2 += delta.y * delta.y;
1410     }
1411
1412     if(dirZ != None)
1413     {
1414       distance2 += delta.z * delta.z;
1415     }
1416
1417     if(closestChild) // Next time.
1418     {
1419       if(distance2 < closestDistance2)
1420       {
1421         closestChild = child;
1422         closestDistance2 = distance2;
1423       }
1424     }
1425     else // First time.
1426     {
1427       closestChild = child;
1428       closestDistance2 = distance2;
1429     }
1430   }
1431
1432   return closestChild;
1433 }
1434
1435 bool ScrollView::ScrollToSnapPoint()
1436 {
1437   DALI_LOG_SCROLL_STATE("[0x%X]", this );
1438   Vector2 stationaryVelocity = Vector2(0.0f, 0.0f);
1439   return SnapWithVelocity( stationaryVelocity );
1440 }
1441
1442 // TODO: In situations where axes are different (X snap, Y free)
1443 // Each axis should really have their own independent animation (time and equation)
1444 // Consider, X axis snapping to nearest grid point (EaseOut over fixed time)
1445 // Consider, Y axis simulating physics to arrive at a point (Physics equation over variable time)
1446 // Currently, the axes have been split however, they both use the same EaseOut equation.
1447 bool ScrollView::SnapWithVelocity(Vector2 velocity)
1448 {
1449   // Animator takes over now, touches are assumed not to interfere.
1450   // And if touches do interfere, then we'll stop animation, update PrePosition
1451   // to current mScroll's properties, and then resume.
1452   // Note: For Flicking this may work a bit different...
1453
1454   float angle = atan2(velocity.y, velocity.x);
1455   float speed2 = velocity.LengthSquared();
1456   AlphaFunction alphaFunction = mSnapAlphaFunction;
1457   Vector2 positionDuration = Vector2::ONE * mSnapDuration;
1458   float biasX = 0.5f;
1459   float biasY = 0.5f;
1460   FindDirection horizontal = None;
1461   FindDirection vertical = None;
1462
1463   // orthoAngleRange = Angle tolerance within the Exact N,E,S,W direction
1464   // that will be accepted as a general N,E,S,W flick direction.
1465
1466   const float orthoAngleRange = FLICK_ORTHO_ANGLE_RANGE * M_PI / 180.0f;
1467   const float flickSpeedThreshold2 = mFlickSpeedThreshold * mFlickSpeedThreshold;
1468
1469   Vector2 positionSnap = mScrollPrePosition;
1470
1471   // Flick logic X Axis
1472
1473   if(mRulerX->IsEnabled() && mLockAxis != LockHorizontal)
1474   {
1475     horizontal = All;
1476
1477     if( speed2 > flickSpeedThreshold2 || // exceeds flick threshold
1478         mInAccessibilityPan ) // With AccessibilityPan its easier to move between snap positions
1479     {
1480       if((angle >= -orthoAngleRange) && (angle < orthoAngleRange)) // Swiping East
1481       {
1482         biasX = 0.0f, horizontal = Left;
1483
1484         // This guards against an error where no movement occurs, due to the flick finishing
1485         // before the update-thread has advanced mScrollPostPosition past the the previous snap point.
1486         positionSnap.x += 1.0f;
1487       }
1488       else if((angle >= M_PI-orthoAngleRange) || (angle < -M_PI+orthoAngleRange)) // Swiping West
1489       {
1490         biasX = 1.0f, horizontal = Right;
1491
1492         // This guards against an error where no movement occurs, due to the flick finishing
1493         // before the update-thread has advanced mScrollPostPosition past the the previous snap point.
1494         positionSnap.x -= 1.0f;
1495       }
1496     }
1497   }
1498
1499   // Flick logic Y Axis
1500
1501   if(mRulerY->IsEnabled() && mLockAxis != LockVertical)
1502   {
1503     vertical = All;
1504
1505     if( speed2 > flickSpeedThreshold2 || // exceeds flick threshold
1506         mInAccessibilityPan ) // With AccessibilityPan its easier to move between snap positions
1507     {
1508       if((angle >= M_PI_2-orthoAngleRange) && (angle < M_PI_2+orthoAngleRange)) // Swiping South
1509       {
1510         biasY = 0.0f, vertical = Up;
1511       }
1512       else if((angle >= -M_PI_2-orthoAngleRange) && (angle < -M_PI_2+orthoAngleRange)) // Swiping North
1513       {
1514         biasY = 1.0f, vertical = Down;
1515       }
1516     }
1517   }
1518
1519   // isFlick: Whether this gesture is a flick or not.
1520   bool isFlick = (horizontal != All || vertical != All);
1521   // isFreeFlick: Whether this gesture is a flick under free panning criteria.
1522   bool isFreeFlick = velocity.LengthSquared() > (FREE_FLICK_SPEED_THRESHOLD*FREE_FLICK_SPEED_THRESHOLD);
1523
1524   if(isFlick || isFreeFlick)
1525   {
1526     positionDuration = Vector2::ONE * mFlickDuration;
1527     alphaFunction = mFlickAlphaFunction;
1528   }
1529
1530   // Calculate next positionSnap ////////////////////////////////////////////////////////////
1531
1532   if(mActorAutoSnapEnabled)
1533   {
1534     Vector3 size = Self().GetCurrentSize();
1535
1536     Actor child = FindClosestActorToPosition( Vector3(size.width * 0.5f,size.height * 0.5f,0.0f), horizontal, vertical );
1537
1538     if(!child && isFlick )
1539     {
1540       // If we conducted a direction limited search and found no actor, then just snap to the closest actor.
1541       child = FindClosestActorToPosition( Vector3(size.width * 0.5f,size.height * 0.5f,0.0f) );
1542     }
1543
1544     if(child)
1545     {
1546       Vector2 position = Self().GetProperty<Vector2>(Toolkit::ScrollView::Property::SCROLL_POSITION);
1547
1548       // Get center-point of the Actor.
1549       Vector3 childPosition = GetPositionOfAnchor(child, AnchorPoint::CENTER);
1550
1551       if(mRulerX->IsEnabled())
1552       {
1553         positionSnap.x = position.x - childPosition.x + size.width * 0.5f;
1554       }
1555       if(mRulerY->IsEnabled())
1556       {
1557         positionSnap.y = position.y - childPosition.y + size.height * 0.5f;
1558       }
1559     }
1560   }
1561
1562   Vector2 startPosition = positionSnap;
1563   positionSnap.x = -mRulerX->Snap(-positionSnap.x, biasX);  // NOTE: X & Y rulers think in -ve coordinate system.
1564   positionSnap.y = -mRulerY->Snap(-positionSnap.y, biasY);  // That is scrolling RIGHT (e.g. 100.0, 0.0) means moving LEFT.
1565
1566   Vector2 clampDelta(Vector2::ZERO);
1567   ClampPosition(positionSnap);
1568
1569   if( (mRulerX->GetType() == Ruler::Free || mRulerY->GetType() == Ruler::Free)
1570       && isFreeFlick && !mActorAutoSnapEnabled)
1571   {
1572     // Calculate target position based on velocity of flick.
1573
1574     // a = Deceleration (Set to diagonal stage length * friction coefficient)
1575     // u = Initial Velocity (Flick velocity)
1576     // v = 0 (Final Velocity)
1577     // t = Time (Velocity / Deceleration)
1578     Vector2 stageSize = Stage::GetCurrent().GetSize();
1579     float stageLength = Vector3(stageSize.x, stageSize.y, 0.0f).Length();
1580     float a = (stageLength * mFrictionCoefficient);
1581     Vector3 u = Vector3(velocity.x, velocity.y, 0.0f) * mFlickSpeedCoefficient;
1582     float speed = u.Length();
1583     u/= speed;
1584
1585     // TODO: Change this to a decay function. (faster you flick, the slower it should be)
1586     speed = std::min(speed, stageLength * mMaxFlickSpeed );
1587     u*= speed;
1588     alphaFunction = ConstantDecelerationAlphaFunction;
1589
1590     float t = speed / a;
1591
1592     if(mRulerX->IsEnabled() && mRulerX->GetType() == Ruler::Free)
1593     {
1594       positionSnap.x += t*u.x*0.5f;
1595     }
1596
1597     if(mRulerY->IsEnabled() && mRulerY->GetType() == Ruler::Free)
1598     {
1599       positionSnap.y += t*u.y*0.5f;
1600     }
1601
1602     clampDelta = positionSnap;
1603     ClampPosition(positionSnap);
1604     if((positionSnap - startPosition).LengthSquared() > Math::MACHINE_EPSILON_0)
1605     {
1606       clampDelta -= positionSnap;
1607       clampDelta.x = clampDelta.x > 0.0f ? std::min(clampDelta.x, mMaxOvershoot.x) : std::max(clampDelta.x, -mMaxOvershoot.x);
1608       clampDelta.y = clampDelta.y > 0.0f ? std::min(clampDelta.y, mMaxOvershoot.y) : std::max(clampDelta.y, -mMaxOvershoot.y);
1609     }
1610     else
1611     {
1612       clampDelta = Vector2::ZERO;
1613     }
1614
1615     // If Axis is Free and has velocity, then calculate time taken
1616     // to reach target based on velocity in axis.
1617     if(mRulerX->IsEnabled() && mRulerX->GetType() == Ruler::Free)
1618     {
1619       float deltaX = fabsf(startPosition.x - positionSnap.x);
1620
1621       if(fabsf(u.x) > Math::MACHINE_EPSILON_1)
1622       {
1623         positionDuration.x = fabsf(deltaX / u.x);
1624       }
1625       else
1626       {
1627         positionDuration.x = 0;
1628       }
1629     }
1630
1631     if(mRulerY->IsEnabled() && mRulerY->GetType() == Ruler::Free)
1632     {
1633       float deltaY = fabsf(startPosition.y - positionSnap.y);
1634
1635       if(fabsf(u.y) > Math::MACHINE_EPSILON_1)
1636       {
1637         positionDuration.y = fabsf(deltaY / u.y);
1638       }
1639       else
1640       {
1641         positionDuration.y = 0;
1642       }
1643     }
1644   }
1645
1646   if(IsOvershootEnabled())
1647   {
1648     // Scroll to the end of the overshoot only when overshoot is enabled.
1649     positionSnap += clampDelta;
1650   }
1651
1652   bool animating = AnimateTo(positionSnap, positionDuration,
1653                              alphaFunction, false,
1654                              DirectionBiasNone, DirectionBiasNone,
1655                              isFlick || isFreeFlick ? Flick : Snap);
1656
1657   return animating;
1658 }
1659
1660 void ScrollView::StopAnimation(void)
1661 {
1662   // Clear Snap animation if exists.
1663   StopAnimation(mInternalXAnimation);
1664   StopAnimation(mInternalYAnimation);
1665   mScrollStateFlags = 0;
1666   // remove scroll animation flags
1667   HandleStoppedAnimation();
1668 }
1669
1670 void ScrollView::StopAnimation(Animation& animation)
1671 {
1672   if(animation)
1673   {
1674     animation.Stop();
1675     animation.Reset();
1676   }
1677 }
1678
1679 bool ScrollView::AnimateTo(const Vector2& position, const Vector2& positionDuration,
1680                            AlphaFunction alpha, bool findShortcuts,
1681                            DirectionBias horizontalBias, DirectionBias verticalBias,
1682                            SnapType snapType)
1683 {
1684   // Here we perform an animation on a number of properties (depending on which have changed)
1685   // The animation is applied to all ScrollBases
1686   Actor self = Self();
1687   mScrollTargetPosition = position;
1688   float totalDuration = 0.0f;
1689
1690   bool positionChanged = (mScrollTargetPosition != mScrollPostPosition);
1691
1692   if(positionChanged)
1693   {
1694     totalDuration = std::max(totalDuration, positionDuration.x);
1695     totalDuration = std::max(totalDuration, positionDuration.y);
1696   }
1697   else
1698   {
1699     // try to animate for a frame, on some occasions update will be changing scroll value while event side thinks it hasnt changed
1700     totalDuration = 0.01f;
1701     positionChanged = true;
1702   }
1703
1704   StopAnimation();
1705
1706   // Position Delta ///////////////////////////////////////////////////////
1707   if(positionChanged)
1708   {
1709     if(mWrapMode && findShortcuts)
1710     {
1711       // In Wrap Mode, the shortest distance is a little less intuitive...
1712       const RulerDomain rulerDomainX = mRulerX->GetDomain();
1713       const RulerDomain rulerDomainY = mRulerY->GetDomain();
1714
1715       if(mRulerX->IsEnabled())
1716       {
1717         float dir = VectorInDomain(-mScrollPrePosition.x, -mScrollTargetPosition.x, rulerDomainX.min, rulerDomainX.max, horizontalBias);
1718         mScrollTargetPosition.x = mScrollPrePosition.x + -dir;
1719       }
1720
1721       if(mRulerY->IsEnabled())
1722       {
1723         float dir = VectorInDomain(-mScrollPrePosition.y, -mScrollTargetPosition.y, rulerDomainY.min, rulerDomainY.max, verticalBias);
1724         mScrollTargetPosition.y = mScrollPrePosition.y + -dir;
1725       }
1726     }
1727
1728     // note we have two separate animations for X & Y, this deals with sliding diagonally and hitting
1729     // a horizonal/vertical wall.delay
1730     AnimateInternalXTo(mScrollTargetPosition.x, positionDuration.x, alpha);
1731     AnimateInternalYTo(mScrollTargetPosition.y, positionDuration.y, alpha);
1732
1733     if( !(mScrollStateFlags & SCROLL_ANIMATION_FLAGS) )
1734     {
1735       DALI_LOG_SCROLL_STATE("[0x%X] Setting SCROLL_PRE_POSITION To[%.2f, %.2f]", this, mScrollTargetPosition.x, mScrollTargetPosition.y );
1736       self.SetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, mScrollTargetPosition);
1737       mScrollPrePosition = mScrollTargetPosition;
1738       mScrollPostPosition = mScrollTargetPosition;
1739       WrapPosition(mScrollPostPosition);
1740     }
1741
1742     DALI_LOG_SCROLL_STATE("[0x%X] position-changed, mScrollTargetPosition[%.2f, %.2f], mScrollPrePosition[%.2f, %.2f], mScrollPostPosition[%.2f, %.2f]", this, mScrollTargetPosition.x, mScrollTargetPosition.y, mScrollPrePosition.x, mScrollPrePosition.y, mScrollPostPosition.x, mScrollPostPosition.y );
1743     DALI_LOG_SCROLL_STATE("[0x%X] SCROLL_PRE_POSITION[%.2f, %.2f], SCROLL_POSITION[%.2f, %.2f]", this, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get<Vector2>().x, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ).Get<Vector2>().y, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_POSITION ).Get<Vector2>().x, self.GetProperty( Toolkit::ScrollView::Property::SCROLL_POSITION ).Get<Vector2>().y );
1744   }
1745
1746   SetScrollUpdateNotification(true);
1747
1748   // Always send a snap event when AnimateTo is called.
1749   Toolkit::ScrollView::SnapEvent snapEvent;
1750   snapEvent.type = snapType;
1751   snapEvent.position = -mScrollTargetPosition;
1752   snapEvent.duration = totalDuration;
1753
1754   DALI_LOG_SCROLL_STATE("[0x%X] mSnapStartedSignal [%.2f, %.2f]", this, snapEvent.position.x, snapEvent.position.y);
1755   mSnapStartedSignal.Emit( snapEvent );
1756
1757   return (mScrollStateFlags & SCROLL_ANIMATION_FLAGS) != 0;
1758 }
1759
1760 void ScrollView::EnableScrollOvershoot(bool enable)
1761 {
1762   if (enable)
1763   {
1764     if (!mOvershootIndicator)
1765     {
1766       mOvershootIndicator = ScrollOvershootIndicator::New();
1767     }
1768
1769     mOvershootIndicator->AttachToScrollable(*this);
1770   }
1771   else
1772   {
1773     mMaxOvershoot = mUserMaxOvershoot;
1774
1775     if (mOvershootIndicator)
1776     {
1777       mOvershootIndicator->DetachFromScrollable(*this);
1778     }
1779   }
1780
1781   UpdateMainInternalConstraint();
1782 }
1783
1784 void ScrollView::AddOverlay(Actor actor)
1785 {
1786   actor.SetDrawMode( DrawMode::OVERLAY_2D );
1787   mInternalActor.Add( actor );
1788 }
1789
1790 void ScrollView::RemoveOverlay(Actor actor)
1791 {
1792   mInternalActor.Remove( actor );
1793 }
1794
1795 void ScrollView::SetOvershootEffectColor( const Vector4& color )
1796 {
1797   mOvershootEffectColor = color;
1798   if( mOvershootIndicator )
1799   {
1800     mOvershootIndicator->SetOvershootEffectColor( color );
1801   }
1802 }
1803
1804 void ScrollView::SetScrollingDirection( Radian direction, Radian threshold )
1805 {
1806   PanGestureDetector panGesture( GetPanGestureDetector() );
1807
1808   // First remove just in case we have some set, then add.
1809   panGesture.RemoveDirection( direction );
1810   panGesture.AddDirection( direction, threshold );
1811 }
1812
1813 void ScrollView::RemoveScrollingDirection( Radian direction )
1814 {
1815   PanGestureDetector panGesture( GetPanGestureDetector() );
1816   panGesture.RemoveDirection( direction );
1817 }
1818
1819 Toolkit::ScrollView::SnapStartedSignalType& ScrollView::SnapStartedSignal()
1820 {
1821   return mSnapStartedSignal;
1822 }
1823
1824 void ScrollView::FindAndUnbindActor(Actor child)
1825 {
1826   UnbindActor(child);
1827 }
1828
1829 Vector2 ScrollView::GetPropertyPrePosition() const
1830 {
1831   Vector2 position = Self().GetProperty<Vector2>(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION);
1832   WrapPosition(position);
1833   return position;
1834 }
1835
1836 Vector2 ScrollView::GetPropertyPosition() const
1837 {
1838   Vector2 position = Self().GetProperty<Vector2>(Toolkit::ScrollView::Property::SCROLL_POSITION);
1839   WrapPosition(position);
1840
1841   return position;
1842 }
1843
1844 void ScrollView::HandleStoppedAnimation()
1845 {
1846   SetScrollUpdateNotification(false);
1847 }
1848
1849 void ScrollView::HandleSnapAnimationFinished()
1850 {
1851   // Emit Signal that scrolling has completed.
1852   mScrolling = false;
1853   Actor self = Self();
1854   self.SetProperty(Toolkit::ScrollView::Property::SCROLLING, false);
1855
1856   Vector2 deltaPosition(mScrollPrePosition);
1857
1858   UpdateLocalScrollProperties();
1859   WrapPosition(mScrollPrePosition);
1860   DALI_LOG_SCROLL_STATE("[0x%X] Setting SCROLL_PRE_POSITION To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
1861   self.SetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, mScrollPrePosition);
1862
1863   Vector2 currentScrollPosition = GetCurrentScrollPosition();
1864   DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 3 current[%.2f, %.2f], mScrollTargetPosition[%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y, -mScrollTargetPosition.x, -mScrollTargetPosition.y );
1865   mScrollCompletedSignal.Emit( currentScrollPosition );
1866
1867   mDomainOffset += deltaPosition - mScrollPostPosition;
1868   self.SetProperty(Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET, mDomainOffset);
1869   HandleStoppedAnimation();
1870 }
1871
1872 void ScrollView::SetScrollUpdateNotification( bool enabled )
1873 {
1874   Actor self = Self();
1875   if( mScrollXUpdateNotification )
1876   {
1877     // disconnect now to avoid a notification before removed from update thread
1878     mScrollXUpdateNotification.NotifySignal().Disconnect(this, &ScrollView::OnScrollUpdateNotification);
1879     self.RemovePropertyNotification(mScrollXUpdateNotification);
1880     mScrollXUpdateNotification.Reset();
1881   }
1882   if( enabled && !mScrollUpdatedSignal.Empty())
1883   {
1884     // Only set up the notification when the application has connected to the updated signal
1885     mScrollXUpdateNotification = self.AddPropertyNotification(Toolkit::ScrollView::Property::SCROLL_POSITION, 0, StepCondition(mScrollUpdateDistance, 0.0f));
1886     mScrollXUpdateNotification.NotifySignal().Connect( this, &ScrollView::OnScrollUpdateNotification );
1887   }
1888   if( mScrollYUpdateNotification )
1889   {
1890     // disconnect now to avoid a notification before removed from update thread
1891     mScrollYUpdateNotification.NotifySignal().Disconnect(this, &ScrollView::OnScrollUpdateNotification);
1892     self.RemovePropertyNotification(mScrollYUpdateNotification);
1893     mScrollYUpdateNotification.Reset();
1894   }
1895   if( enabled && !mScrollUpdatedSignal.Empty())
1896   {
1897     // Only set up the notification when the application has connected to the updated signal
1898     mScrollYUpdateNotification = self.AddPropertyNotification(Toolkit::ScrollView::Property::SCROLL_POSITION, 1, StepCondition(mScrollUpdateDistance, 0.0f));
1899     mScrollYUpdateNotification.NotifySignal().Connect( this, &ScrollView::OnScrollUpdateNotification );
1900   }
1901 }
1902
1903 void ScrollView::OnScrollUpdateNotification(Dali::PropertyNotification& source)
1904 {
1905   // Guard against destruction during signal emission
1906   Toolkit::ScrollView handle( GetOwner() );
1907
1908   Vector2 currentScrollPosition = GetCurrentScrollPosition();
1909   mScrollUpdatedSignal.Emit( currentScrollPosition );
1910 }
1911
1912 bool ScrollView::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
1913 {
1914   Dali::BaseHandle handle( object );
1915
1916   bool connected( true );
1917   Toolkit::ScrollView view = Toolkit::ScrollView::DownCast( handle );
1918
1919   if( 0 == strcmp( signalName.c_str(), SIGNAL_SNAP_STARTED ) )
1920   {
1921     view.SnapStartedSignal().Connect( tracker, functor );
1922   }
1923   else
1924   {
1925     // signalName does not match any signal
1926     connected = false;
1927   }
1928
1929   return connected;
1930 }
1931
1932 void ScrollView::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
1933 {
1934   // need to update domain properties for new size
1935   UpdatePropertyDomain();
1936 }
1937
1938 void ScrollView::OnSizeSet( const Vector3& size )
1939 {
1940   // need to update domain properties for new size
1941   if( mDefaultMaxOvershoot )
1942   {
1943     mUserMaxOvershoot.x = size.x * 0.5f;
1944     mUserMaxOvershoot.y = size.y * 0.5f;
1945     if( !IsOvershootEnabled() )
1946     {
1947       mMaxOvershoot = mUserMaxOvershoot;
1948     }
1949   }
1950   UpdatePropertyDomain();
1951   UpdateMainInternalConstraint();
1952   if( IsOvershootEnabled() )
1953   {
1954     mOvershootIndicator->Reset();
1955   }
1956 }
1957
1958 void ScrollView::OnChildAdd(Actor& child)
1959 {
1960   ScrollBase::OnChildAdd( child );
1961
1962   Dali::Toolkit::ScrollBar scrollBar = Dali::Toolkit::ScrollBar::DownCast(child);
1963   if(scrollBar)
1964   {
1965     mInternalActor.Add(scrollBar);
1966     if(scrollBar.GetScrollDirection() == Toolkit::ScrollBar::Horizontal)
1967     {
1968       scrollBar.SetScrollPropertySource(Self(),
1969                                         Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X,
1970                                         Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X,
1971                                         Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X,
1972                                         Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X);
1973     }
1974     else
1975     {
1976       scrollBar.SetScrollPropertySource(Self(),
1977                                         Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y,
1978                                         Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y,
1979                                         Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y,
1980                                         Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y);
1981     }
1982   }
1983   else if(mAlterChild)
1984   {
1985     BindActor(child);
1986   }
1987 }
1988
1989 void ScrollView::OnChildRemove(Actor& child)
1990 {
1991   // TODO: Actor needs a RemoveConstraint method to take out an individual constraint.
1992   UnbindActor(child);
1993
1994   ScrollBase::OnChildRemove( child );
1995 }
1996
1997 void ScrollView::StartTouchDownTimer()
1998 {
1999   if ( !mTouchDownTimer )
2000   {
2001     mTouchDownTimer = Timer::New( TOUCH_DOWN_TIMER_INTERVAL );
2002     mTouchDownTimer.TickSignal().Connect( this, &ScrollView::OnTouchDownTimeout );
2003   }
2004
2005   mTouchDownTimer.Start();
2006 }
2007
2008 void ScrollView::StopTouchDownTimer()
2009 {
2010   if ( mTouchDownTimer )
2011   {
2012     mTouchDownTimer.Stop();
2013   }
2014 }
2015
2016 bool ScrollView::OnTouchDownTimeout()
2017 {
2018   DALI_LOG_SCROLL_STATE("[0x%X]", this);
2019
2020   mTouchDownTimeoutReached = true;
2021
2022   unsigned int currentScrollStateFlags( mScrollStateFlags ); // Cleared in StopAnimation so keep local copy for comparison
2023   if( currentScrollStateFlags & (SCROLL_ANIMATION_FLAGS | SNAP_ANIMATION_FLAGS) )
2024   {
2025     DALI_LOG_SCROLL_STATE("[0x%X] Scrolling Or snapping flags set, stopping animation", this);
2026
2027     StopAnimation();
2028     if( currentScrollStateFlags & SCROLL_ANIMATION_FLAGS )
2029     {
2030       DALI_LOG_SCROLL_STATE("[0x%X] Scrolling flags set, emitting signal", this);
2031
2032       mScrollInterrupted = true;
2033       // reset domain offset as scrolling from original plane.
2034       mDomainOffset = Vector2::ZERO;
2035       Self().SetProperty(Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET, Vector2::ZERO);
2036
2037       UpdateLocalScrollProperties();
2038       Vector2 currentScrollPosition = GetCurrentScrollPosition();
2039       DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 4 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
2040       mScrollCompletedSignal.Emit( currentScrollPosition );
2041     }
2042   }
2043
2044   return false;
2045 }
2046
2047 bool ScrollView::OnTouch( Actor actor, const TouchData& touch )
2048 {
2049   if(!mSensitive)
2050   {
2051     DALI_LOG_SCROLL_STATE("[0x%X], Not Sensitive, ignoring", this);
2052
2053     // Ignore this touch event, if scrollview is insensitive.
2054     return false;
2055   }
2056
2057   // Ignore events with multiple-touch points
2058   if (touch.GetPointCount() != 1)
2059   {
2060     DALI_LOG_SCROLL_STATE("[0x%X], multiple touch, ignoring", this);
2061
2062     return false;
2063   }
2064
2065   const PointState::Type pointState = touch.GetState( 0 );
2066   if( pointState == PointState::DOWN )
2067   {
2068     DALI_LOG_SCROLL_STATE("[0x%X] Down", this);
2069
2070     if(mGestureStackDepth==0)
2071     {
2072       mTouchDownTime = touch.GetTime();
2073
2074       // This allows time for a pan-gesture to start, to avoid breaking snap-animation behavior with fast flicks.
2075       // If touch-down does not become a pan (after timeout interval), then snap-animation can be interrupted.
2076       mTouchDownTimeoutReached = false;
2077       mScrollInterrupted = false;
2078       StartTouchDownTimer();
2079     }
2080   }
2081   else if( ( pointState == PointState::UP ) ||
2082            ( ( pointState == PointState::INTERRUPTED ) && ( touch.GetHitActor( 0 )== Self() ) ) )
2083   {
2084     DALI_LOG_SCROLL_STATE("[0x%X] %s", this, ( ( pointState == TouchPoint::Up ) ? "Up" : "Interrupted" ) );
2085
2086     StopTouchDownTimer();
2087
2088     // if the user touches and releases without enough movement to go
2089     // into a gesture state, then we should snap to nearest point.
2090     // otherwise our scroll could be stopped (interrupted) half way through an animation.
2091     if(mGestureStackDepth==0 && mTouchDownTimeoutReached)
2092     {
2093       if( ( pointState == PointState::INTERRUPTED ) ||
2094           ( ( touch.GetTime() - mTouchDownTime ) >= MINIMUM_TIME_BETWEEN_DOWN_AND_UP_FOR_RESET ) )
2095       {
2096         // Reset the velocity only if down was received a while ago
2097         mLastVelocity = Vector2( 0.0f, 0.0f );
2098       }
2099
2100       UpdateLocalScrollProperties();
2101       // Only finish the transform if scrolling was interrupted on down or if we are scrolling
2102       if ( mScrollInterrupted || mScrolling )
2103       {
2104         DALI_LOG_SCROLL_STATE("[0x%X] Calling FinishTransform", this);
2105
2106         FinishTransform();
2107       }
2108     }
2109     mTouchDownTimeoutReached = false;
2110     mScrollInterrupted = false;
2111   }
2112
2113   return true;
2114 }
2115
2116 bool ScrollView::OnWheelEvent(const WheelEvent& event)
2117 {
2118   if(!mSensitive)
2119   {
2120     // Ignore this wheel event, if scrollview is insensitive.
2121     return false;
2122   }
2123
2124   Vector2 targetScrollPosition = GetPropertyPosition();
2125
2126   if(mRulerX->IsEnabled() && !mRulerY->IsEnabled())
2127   {
2128     // If only the ruler in the X axis is enabled, scroll in the X axis.
2129     if(mRulerX->GetType() == Ruler::Free)
2130     {
2131       // Free panning mode
2132       targetScrollPosition.x += event.z * mWheelScrollDistanceStep.x;
2133       ClampPosition(targetScrollPosition);
2134       ScrollTo(-targetScrollPosition);
2135     }
2136     else if(!mScrolling)
2137     {
2138       // Snap mode, only respond to the event when the previous snap animation is finished.
2139       ScrollTo(GetCurrentPage() - event.z);
2140     }
2141   }
2142   else
2143   {
2144     // If the ruler in the Y axis is enabled, scroll in the Y axis.
2145     if(mRulerY->GetType() == Ruler::Free)
2146     {
2147       // Free panning mode
2148       targetScrollPosition.y += event.z * mWheelScrollDistanceStep.y;
2149       ClampPosition(targetScrollPosition);
2150       ScrollTo(-targetScrollPosition);
2151     }
2152     else if(!mScrolling)
2153     {
2154       // Snap mode, only respond to the event when the previous snap animation is finished.
2155       ScrollTo(GetCurrentPage() - event.z * mRulerX->GetTotalPages());
2156     }
2157   }
2158
2159   return true;
2160 }
2161
2162 void ScrollView::ResetScrolling()
2163 {
2164   Actor self = Self();
2165   self.GetProperty(Toolkit::ScrollView::Property::SCROLL_POSITION).Get(mScrollPostPosition);
2166   mScrollPrePosition = mScrollPostPosition;
2167   DALI_LOG_SCROLL_STATE("[0x%X] Setting SCROLL_PRE_POSITION To[%.2f, %.2f]", this, mScrollPostPosition.x, mScrollPostPosition.y );
2168   self.SetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, mScrollPostPosition);
2169 }
2170
2171 void ScrollView::UpdateLocalScrollProperties()
2172 {
2173   Actor self = Self();
2174   self.GetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION).Get(mScrollPrePosition);
2175   self.GetProperty(Toolkit::ScrollView::Property::SCROLL_POSITION).Get(mScrollPostPosition);
2176 }
2177
2178 // private functions
2179
2180 void ScrollView::PreAnimatedScrollSetup()
2181 {
2182   // SCROLL_PRE_POSITION is our unclamped property with wrapping
2183   // SCROLL_POSITION is our final scroll position after clamping
2184
2185   Actor self = Self();
2186
2187   Vector2 deltaPosition(mScrollPostPosition);
2188   WrapPosition(mScrollPostPosition);
2189   mDomainOffset += deltaPosition - mScrollPostPosition;
2190   Self().SetProperty(Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET, mDomainOffset);
2191
2192   if( mScrollStateFlags & SCROLL_X_STATE_MASK )
2193   {
2194     // already performing animation on internal x position
2195     StopAnimation(mInternalXAnimation);
2196   }
2197
2198   if( mScrollStateFlags & SCROLL_Y_STATE_MASK )
2199   {
2200     // already performing animation on internal y position
2201     StopAnimation(mInternalYAnimation);
2202   }
2203
2204   mScrollStateFlags = 0;
2205
2206   // Update Actor position with this wrapped value.
2207 }
2208
2209 void ScrollView::FinaliseAnimatedScroll()
2210 {
2211   // TODO - common animation finishing code in here
2212 }
2213
2214 void ScrollView::AnimateInternalXTo( float position, float duration, AlphaFunction alpha )
2215 {
2216   StopAnimation(mInternalXAnimation);
2217
2218   if( duration > Math::MACHINE_EPSILON_10 )
2219   {
2220     Actor self = Self();
2221     DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, self.GetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION).Get<Vector2>().x, position );
2222     mInternalXAnimation = Animation::New(duration);
2223     DALI_LOG_SCROLL_STATE("[0x%X], mInternalXAnimation[0x%X]", this, mInternalXAnimation.GetObjectPtr() );
2224     mInternalXAnimation.FinishedSignal().Connect(this, &ScrollView::OnScrollAnimationFinished);
2225     mInternalXAnimation.AnimateTo( Property(self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, 0), position, alpha, TimePeriod(duration));
2226     mInternalXAnimation.Play();
2227
2228     // erase current state flags
2229     mScrollStateFlags &= ~SCROLL_X_STATE_MASK;
2230     // add internal animation state flag
2231     mScrollStateFlags |= AnimatingInternalX;
2232   }
2233 }
2234
2235 void ScrollView::AnimateInternalYTo( float position, float duration, AlphaFunction alpha )
2236 {
2237   StopAnimation(mInternalYAnimation);
2238
2239   if( duration > Math::MACHINE_EPSILON_10 )
2240   {
2241     Actor self = Self();
2242     DALI_LOG_SCROLL_STATE("[0x%X], Animating from[%.2f] to[%.2f]", this, self.GetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION).Get<Vector2>().y, position );
2243     mInternalYAnimation = Animation::New(duration);
2244     DALI_LOG_SCROLL_STATE("[0x%X], mInternalYAnimation[0x%X]", this, mInternalYAnimation.GetObjectPtr() );
2245     mInternalYAnimation.FinishedSignal().Connect(this, &ScrollView::OnScrollAnimationFinished);
2246     mInternalYAnimation.AnimateTo( Property(self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, 1), position, alpha, TimePeriod(duration));
2247     mInternalYAnimation.Play();
2248
2249     // erase current state flags
2250     mScrollStateFlags &= ~SCROLL_Y_STATE_MASK;
2251     // add internal animation state flag
2252     mScrollStateFlags |= AnimatingInternalY;
2253   }
2254 }
2255
2256 void ScrollView::OnScrollAnimationFinished( Animation& source )
2257 {
2258   // Guard against destruction during signal emission
2259   // Note that ScrollCompletedSignal is emitted from HandleSnapAnimationFinished()
2260   Toolkit::ScrollView handle( GetOwner() );
2261
2262   bool scrollingFinished = false;
2263
2264   // update our local scroll positions
2265   UpdateLocalScrollProperties();
2266
2267   if( source == mInternalXAnimation )
2268   {
2269     DALI_LOG_SCROLL_STATE("[0x%X] mInternalXAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalXAnimation.GetObjectPtr(), mScrollTargetPosition.x, Self().GetProperty(SCROLL_PRE_POSITION).Get<Vector2>().x, mScrollPostPosition.x );
2270
2271     if( !(mScrollStateFlags & AnimatingInternalY) )
2272     {
2273       scrollingFinished = true;
2274     }
2275     mInternalXAnimation.Reset();
2276     // wrap pre scroll x position and set it
2277     if( mWrapMode )
2278     {
2279       const RulerDomain rulerDomain = mRulerX->GetDomain();
2280       mScrollPrePosition.x = -WrapInDomain(-mScrollPrePosition.x, rulerDomain.min, rulerDomain.max);
2281       DALI_LOG_SCROLL_STATE("[0x%X] Setting SCROLL_PRE_POSITION To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
2282       handle.SetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, mScrollPrePosition);
2283     }
2284     SnapInternalXTo(mScrollPostPosition.x);
2285   }
2286
2287   if( source == mInternalYAnimation )
2288   {
2289     DALI_LOG_SCROLL_STATE("[0x%X] mInternalYAnimation[0x%X], expected[%.2f], actual[%.2f], post[%.2f]", this, mInternalYAnimation.GetObjectPtr(), mScrollTargetPosition.y, Self().GetProperty(SCROLL_PRE_POSITION).Get<Vector2>().y, mScrollPostPosition.y );
2290
2291     if( !(mScrollStateFlags & AnimatingInternalX) )
2292     {
2293       scrollingFinished = true;
2294     }
2295     mInternalYAnimation.Reset();
2296     if( mWrapMode )
2297     {
2298       // wrap pre scroll y position and set it
2299       const RulerDomain rulerDomain = mRulerY->GetDomain();
2300       mScrollPrePosition.y = -WrapInDomain(-mScrollPrePosition.y, rulerDomain.min, rulerDomain.max);
2301       DALI_LOG_SCROLL_STATE("[0x%X] Setting SCROLL_PRE_POSITION To[%.2f, %.2f]", this, mScrollPrePosition.x, mScrollPrePosition.y );
2302       handle.SetProperty(Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, mScrollPrePosition);
2303     }
2304     SnapInternalYTo(mScrollPostPosition.y);
2305   }
2306
2307   DALI_LOG_SCROLL_STATE("[0x%X] scrollingFinished[%d] Animation[0x%X]", this, scrollingFinished, source.GetObjectPtr());
2308
2309   if(scrollingFinished)
2310   {
2311     HandleSnapAnimationFinished();
2312   }
2313 }
2314
2315 void ScrollView::OnSnapInternalPositionFinished( Animation& source )
2316 {
2317   Actor self = Self();
2318   UpdateLocalScrollProperties();
2319   if( source == mInternalXAnimation )
2320   {
2321     DALI_LOG_SCROLL_STATE("[0x%X] Finished X PostPosition Animation", this );
2322
2323     // clear internal x animation flags
2324     mScrollStateFlags &= ~SCROLL_X_STATE_MASK;
2325     mInternalXAnimation.Reset();
2326     WrapPosition(mScrollPrePosition);
2327   }
2328   if( source == mInternalYAnimation )
2329   {
2330     DALI_LOG_SCROLL_STATE("[0x%X] Finished Y PostPosition Animation", this );
2331
2332     mScrollStateFlags &= ~SCROLL_Y_STATE_MASK;
2333     mInternalYAnimation.Reset();
2334     WrapPosition(mScrollPrePosition);
2335   }
2336 }
2337
2338 void ScrollView::SnapInternalXTo(float position)
2339 {
2340   Actor self = Self();
2341
2342   StopAnimation(mInternalXAnimation);
2343
2344   // erase current state flags
2345   mScrollStateFlags &= ~SCROLL_X_STATE_MASK;
2346
2347   // if internal x not equal to inputed parameter, animate it
2348   float duration = std::min(fabsf((position - mScrollPrePosition.x) / mMaxOvershoot.x) * mSnapOvershootDuration, mSnapOvershootDuration);
2349   DALI_LOG_SCROLL_STATE("[0x%X] duration[%.2f]", this, duration );
2350   if( duration > Math::MACHINE_EPSILON_1 )
2351   {
2352     DALI_LOG_SCROLL_STATE("[0x%X] Starting X Snap Animation to[%.2f]", this, position );
2353
2354     mInternalXAnimation = Animation::New(duration);
2355     mInternalXAnimation.FinishedSignal().Connect(this, &ScrollView::OnSnapInternalPositionFinished);
2356     mInternalXAnimation.AnimateTo(Property(self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, 0), position);
2357     mInternalXAnimation.Play();
2358
2359     // add internal animation state flag
2360     mScrollStateFlags |= SnappingInternalX;
2361   }
2362 }
2363
2364 void ScrollView::SnapInternalYTo(float position)
2365 {
2366   Actor self = Self();
2367
2368   StopAnimation(mInternalYAnimation);
2369
2370   // erase current state flags
2371   mScrollStateFlags &= ~SCROLL_Y_STATE_MASK;
2372
2373   // if internal y not equal to inputed parameter, animate it
2374   float duration = std::min(fabsf((position - mScrollPrePosition.y) / mMaxOvershoot.y) * mSnapOvershootDuration, mSnapOvershootDuration);
2375   DALI_LOG_SCROLL_STATE("[0x%X] duration[%.2f]", this, duration );
2376   if( duration > Math::MACHINE_EPSILON_1 )
2377   {
2378     DALI_LOG_SCROLL_STATE("[0x%X] Starting Y Snap Animation to[%.2f]", this, position );
2379
2380     mInternalYAnimation = Animation::New(duration);
2381     mInternalYAnimation.FinishedSignal().Connect(this, &ScrollView::OnSnapInternalPositionFinished);
2382     mInternalYAnimation.AnimateTo(Property(self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION, 1), position);
2383     mInternalYAnimation.Play();
2384
2385     // add internal animation state flag
2386     mScrollStateFlags |= SnappingInternalY;
2387   }
2388 }
2389
2390 void ScrollView::GestureStarted()
2391 {
2392   // we handle the first gesture.
2393   // if we're currently doing a gesture and receive another
2394   // we continue and combine the effects of the gesture instead of reseting.
2395   if(mGestureStackDepth++==0)
2396   {
2397     Actor self = Self();
2398     StopTouchDownTimer();
2399     StopAnimation();
2400     mPanDelta = Vector2::ZERO;
2401     mLastVelocity = Vector2::ZERO;
2402     if( !mScrolling )
2403     {
2404       mLockAxis = LockPossible;
2405     }
2406
2407     if( mScrollStateFlags & SCROLL_X_STATE_MASK )
2408     {
2409       StopAnimation(mInternalXAnimation);
2410     }
2411     if( mScrollStateFlags & SCROLL_Y_STATE_MASK )
2412     {
2413       StopAnimation(mInternalYAnimation);
2414     }
2415     mScrollStateFlags = 0;
2416
2417     if(mScrolling) // are we interrupting a current scroll?
2418     {
2419       // set mScrolling to false, in case user has code that interrogates mScrolling Getter() in complete.
2420       mScrolling = false;
2421       // send negative scroll position since scroll internal scroll position works as an offset for actors,
2422       // give applications the position within the domain from the scroll view's anchor position
2423       DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 5 [%.2f, %.2f]", this, -mScrollPostPosition.x, -mScrollPostPosition.y);
2424       mScrollCompletedSignal.Emit( -mScrollPostPosition );
2425     }
2426   }
2427 }
2428
2429 void ScrollView::GestureContinuing(const Vector2& panDelta)
2430 {
2431   mPanDelta.x+= panDelta.x;
2432   mPanDelta.y+= panDelta.y;
2433
2434   // Save the velocity, there is a bug in PanGesture
2435   // Whereby the Gesture::Finished's velocity is either:
2436   // NaN (due to time delta of zero between the last two events)
2437   // or 0 (due to position being the same between the last two events)
2438
2439   // Axis Auto Lock - locks the panning to the horizontal or vertical axis if the pan
2440   // appears mostly horizontal or mostly vertical respectively.
2441   if(mAxisAutoLock)
2442   {
2443     mLockAxis = GetLockAxis(mPanDelta, mLockAxis, mAxisAutoLockGradient);
2444   } // end if mAxisAutoLock
2445 }
2446
2447 // TODO: Upgrade to use a more powerful gesture detector (one that supports multiple touches on pan - so works as pan and flick gesture)
2448 // BUG: Gesture::Finished doesn't always return velocity on release (due to
2449 // timeDelta between last two events being 0 sometimes, or posiiton being the same)
2450 void ScrollView::OnPan( const PanGesture& gesture )
2451 {
2452   // Guard against destruction during signal emission
2453   // Note that Emit() methods are called indirectly e.g. from within ScrollView::OnGestureEx()
2454   Actor self( Self() );
2455
2456   if(!mSensitive)
2457   {
2458     DALI_LOG_SCROLL_STATE("[0x%X] Pan Ignored, Insensitive", this);
2459
2460     // If another callback on the same original signal disables sensitivity,
2461     // this callback will still be called, so we must suppress it.
2462     return;
2463   }
2464
2465   // translate Gesture input to get useful data...
2466   switch(gesture.state)
2467   {
2468     case Gesture::Started:
2469     {
2470       DALI_LOG_SCROLL_STATE("[0x%X] Pan Started", this);
2471       mPanStartPosition = gesture.position - gesture.displacement;
2472       UpdateLocalScrollProperties();
2473       GestureStarted();
2474       mPanning = true;
2475       self.SetProperty( Toolkit::ScrollView::Property::PANNING, true );
2476       self.SetProperty( Toolkit::ScrollView::Property::START_PAGE_POSITION, Vector3(gesture.position.x, gesture.position.y, 0.0f) );
2477
2478       UpdateMainInternalConstraint();
2479       break;
2480     }
2481
2482     case Gesture::Continuing:
2483     {
2484       if ( mPanning )
2485       {
2486         DALI_LOG_SCROLL_STATE("[0x%X] Pan Continuing", this);
2487         GestureContinuing(gesture.screenDisplacement);
2488       }
2489       else
2490       {
2491         // If we do not think we are panning, then we should not do anything here
2492         return;
2493       }
2494       break;
2495     }
2496
2497     case Gesture::Finished:
2498     case Gesture::Cancelled:
2499     {
2500       if ( mPanning )
2501       {
2502         DALI_LOG_SCROLL_STATE("[0x%X] Pan %s", this, ( ( gesture.state == Gesture::Finished ) ? "Finished" : "Cancelled" ) );
2503
2504         UpdateLocalScrollProperties();
2505         mLastVelocity = gesture.velocity;
2506         mPanning = false;
2507         self.SetProperty( Toolkit::ScrollView::Property::PANNING, false );
2508
2509         if( mScrollMainInternalPrePositionConstraint )
2510         {
2511           mScrollMainInternalPrePositionConstraint.Remove();
2512         }
2513       }
2514       else
2515       {
2516         // If we do not think we are panning, then we should not do anything here
2517         return;
2518       }
2519       break;
2520     }
2521
2522     case Gesture::Possible:
2523     case Gesture::Clear:
2524     {
2525       // Nothing to do, not needed.
2526       break;
2527     }
2528
2529   } // end switch(gesture.state)
2530
2531   OnGestureEx(gesture.state);
2532 }
2533
2534 void ScrollView::OnGestureEx(Gesture::State state)
2535 {
2536   // call necessary signals for application developer
2537
2538   if(state == Gesture::Started)
2539   {
2540     Vector2 currentScrollPosition = GetCurrentScrollPosition();
2541     Self().SetProperty(Toolkit::ScrollView::Property::SCROLLING, true);
2542     mScrolling = true;
2543     DALI_LOG_SCROLL_STATE("[0x%X] mScrollStartedSignal 2 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
2544     mScrollStartedSignal.Emit( currentScrollPosition );
2545   }
2546   else if( (state == Gesture::Finished) ||
2547            (state == Gesture::Cancelled) ) // Finished/default
2548   {
2549     // when all the gestures have finished, we finish the transform.
2550     // so if a user decides to pan (1 gesture), and then pan+zoom (2 gestures)
2551     // then stop panning (back to 1 gesture), and then stop zooming (0 gestures).
2552     // this is the point we end, and perform necessary snapping.
2553     mGestureStackDepth--;
2554     if(mGestureStackDepth==0)
2555     {
2556       // no flick if we have not exceeded min flick distance
2557       if( (fabsf(mPanDelta.x) < mMinFlickDistance.x)
2558           && (fabsf(mPanDelta.y) < mMinFlickDistance.y) )
2559       {
2560         // reset flick velocity
2561         mLastVelocity = Vector2::ZERO;
2562       }
2563       FinishTransform();
2564     }
2565     else
2566     {
2567       DALI_LOG_SCROLL_STATE("[0x%X] mGestureStackDepth[%d]", this, mGestureStackDepth);
2568     }
2569   }
2570 }
2571
2572 void ScrollView::FinishTransform()
2573 {
2574   // at this stage internal x and x scroll position should have followed prescroll position exactly
2575   Actor self = Self();
2576
2577   PreAnimatedScrollSetup();
2578
2579   // convert pixels/millisecond to pixels per second
2580   bool animating = SnapWithVelocity(mLastVelocity * 1000.0f);
2581
2582   if(!animating)
2583   {
2584     // if not animating, then this pan has completed right now.
2585     SetScrollUpdateNotification(false);
2586     mScrolling = false;
2587     Self().SetProperty(Toolkit::ScrollView::Property::SCROLLING, false);
2588
2589     if( fabs(mScrollPrePosition.x - mScrollTargetPosition.x) > Math::MACHINE_EPSILON_10 )
2590     {
2591       SnapInternalXTo(mScrollTargetPosition.x);
2592     }
2593     if( fabs(mScrollPrePosition.y - mScrollTargetPosition.y) > Math::MACHINE_EPSILON_10 )
2594     {
2595       SnapInternalYTo(mScrollTargetPosition.y);
2596     }
2597     Vector2 currentScrollPosition = GetCurrentScrollPosition();
2598     DALI_LOG_SCROLL_STATE("[0x%X] mScrollCompletedSignal 6 [%.2f, %.2f]", this, currentScrollPosition.x, currentScrollPosition.y);
2599     mScrollCompletedSignal.Emit( currentScrollPosition );
2600   }
2601 }
2602
2603 Vector2 ScrollView::GetOvershoot(Vector2& position) const
2604 {
2605   Vector3 size = Self().GetCurrentSize();
2606   Vector2 overshoot;
2607
2608   const RulerDomain rulerDomainX = mRulerX->GetDomain();
2609   const RulerDomain rulerDomainY = mRulerY->GetDomain();
2610
2611   if(mRulerX->IsEnabled() && rulerDomainX.enabled)
2612   {
2613     const float left = rulerDomainX.min - position.x;
2614     const float right = size.width - rulerDomainX.max - position.x;
2615     if(left<0)
2616     {
2617       overshoot.x = left;
2618     }
2619     else if(right>0)
2620     {
2621       overshoot.x = right;
2622     }
2623   }
2624
2625   if(mRulerY->IsEnabled() && rulerDomainY.enabled)
2626   {
2627     const float top = rulerDomainY.min - position.y;
2628     const float bottom = size.height - rulerDomainY.max - position.y;
2629     if(top<0)
2630     {
2631       overshoot.y = top;
2632     }
2633     else if(bottom>0)
2634     {
2635       overshoot.y = bottom;
2636     }
2637   }
2638
2639   return overshoot;
2640 }
2641
2642 bool ScrollView::OnAccessibilityPan(PanGesture gesture)
2643 {
2644   // Keep track of whether this is an AccessibilityPan
2645   mInAccessibilityPan = true;
2646   OnPan(gesture);
2647   mInAccessibilityPan = false;
2648
2649   return true;
2650 }
2651
2652 void ScrollView::ClampPosition(Vector2& position) const
2653 {
2654   ClampState2D clamped;
2655   ClampPosition(position, clamped);
2656 }
2657
2658 void ScrollView::ClampPosition(Vector2& position, ClampState2D &clamped) const
2659 {
2660   Vector3 size = Self().GetCurrentSize();
2661
2662   position.x = -mRulerX->Clamp(-position.x, size.width, 1.0f, clamped.x);    // NOTE: X & Y rulers think in -ve coordinate system.
2663   position.y = -mRulerY->Clamp(-position.y, size.height, 1.0f, clamped.y);   // That is scrolling RIGHT (e.g. 100.0, 0.0) means moving LEFT.
2664 }
2665
2666 void ScrollView::WrapPosition(Vector2& position) const
2667 {
2668   if(mWrapMode)
2669   {
2670     const RulerDomain rulerDomainX = mRulerX->GetDomain();
2671     const RulerDomain rulerDomainY = mRulerY->GetDomain();
2672
2673     if(mRulerX->IsEnabled())
2674     {
2675       position.x = -WrapInDomain(-position.x, rulerDomainX.min, rulerDomainX.max);
2676     }
2677
2678     if(mRulerY->IsEnabled())
2679     {
2680       position.y = -WrapInDomain(-position.y, rulerDomainY.min, rulerDomainY.max);
2681     }
2682   }
2683 }
2684
2685 void ScrollView::UpdateMainInternalConstraint()
2686 {
2687   // TODO: Only update the constraints which have changed, rather than remove all and add all again.
2688   // Requires a dali-core ApplyConstraintAt, or a ReplaceConstraint. The former is probably more flexible.
2689   Actor self = Self();
2690   PanGestureDetector detector( GetPanGestureDetector() );
2691
2692   if(mScrollMainInternalPositionConstraint)
2693   {
2694     mScrollMainInternalPositionConstraint.Remove();
2695     mScrollMainInternalDeltaConstraint.Remove();
2696     mScrollMainInternalFinalConstraint.Remove();
2697     mScrollMainInternalRelativeConstraint.Remove();
2698     mScrollMainInternalDomainConstraint.Remove();
2699     mScrollMainInternalPrePositionMaxConstraint.Remove();
2700   }
2701   if( mScrollMainInternalPrePositionConstraint )
2702   {
2703     mScrollMainInternalPrePositionConstraint.Remove();
2704   }
2705
2706   // TODO: It's probably better to use a local displacement value as this will give a displacement when scrolling just commences
2707   // but we need to make sure than the gesture system gives displacement since last frame (60Hz), not displacement since last touch event (90Hz).
2708
2709   // 1. First calculate the pre-position (this is the scroll position if no clamping has taken place)
2710   Vector2 initialPanMask = Vector2(mRulerX->IsEnabled() ? 1.0f : 0.0f, mRulerY->IsEnabled() ? 1.0f : 0.0f);
2711
2712   if( mLockAxis == LockVertical )
2713   {
2714     initialPanMask.y = 0.0f;
2715   }
2716   else if( mLockAxis == LockHorizontal )
2717   {
2718     initialPanMask.x = 0.0f;
2719   }
2720
2721   if( mPanning )
2722   {
2723     mScrollMainInternalPrePositionConstraint = Constraint::New<Vector2>( self,
2724                                                                          Toolkit::ScrollView::Property::SCROLL_PRE_POSITION,
2725                                                                          InternalPrePositionConstraint( mPanStartPosition,
2726                                                                                                         initialPanMask,
2727                                                                                                         mAxisAutoLock,
2728                                                                                                         mAxisAutoLockGradient,
2729                                                                                                         mLockAxis,
2730                                                                                                         mMaxOvershoot,
2731                                                                                                         mRulerX,
2732                                                                                                         mRulerY ) );
2733     mScrollMainInternalPrePositionConstraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
2734     mScrollMainInternalPrePositionConstraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
2735     mScrollMainInternalPrePositionConstraint.AddSource( Source( self, Actor::Property::SIZE ) );
2736     mScrollMainInternalPrePositionConstraint.Apply();
2737   }
2738
2739   // 2. Second calculate the clamped position (actual position)
2740   mScrollMainInternalPositionConstraint = Constraint::New<Vector2>( self,
2741                                                                     Toolkit::ScrollView::Property::SCROLL_POSITION,
2742                                                                     InternalPositionConstraint( mRulerX->GetDomain(),
2743                                                                                                 mRulerY->GetDomain(),
2744                                                                                                 mWrapMode ) );
2745   mScrollMainInternalPositionConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ) );
2746   mScrollMainInternalPositionConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::SCROLL_POSITION_MIN ) );
2747   mScrollMainInternalPositionConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::SCROLL_POSITION_MAX ) );
2748   mScrollMainInternalPositionConstraint.AddSource( Source( self, Actor::Property::SIZE ) );
2749   mScrollMainInternalPositionConstraint.Apply();
2750
2751   mScrollMainInternalDeltaConstraint = Constraint::New<Vector2>( self, Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA, InternalPositionDeltaConstraint );
2752   mScrollMainInternalDeltaConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_POSITION ) );
2753   mScrollMainInternalDeltaConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET ) );
2754   mScrollMainInternalDeltaConstraint.Apply();
2755
2756   mScrollMainInternalFinalConstraint = Constraint::New<Vector2>( self, Toolkit::ScrollView::Property::SCROLL_FINAL,
2757                                                                  InternalFinalConstraint( FinalDefaultAlphaFunction,
2758                                                                                           FinalDefaultAlphaFunction ) );
2759   mScrollMainInternalFinalConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_POSITION ) );
2760   mScrollMainInternalFinalConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::OVERSHOOT_X ) );
2761   mScrollMainInternalFinalConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::OVERSHOOT_Y ) );
2762   mScrollMainInternalFinalConstraint.Apply();
2763
2764   mScrollMainInternalRelativeConstraint = Constraint::New<Vector2>( self, Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION, InternalRelativePositionConstraint );
2765   mScrollMainInternalRelativeConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_POSITION ) );
2766   mScrollMainInternalRelativeConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::SCROLL_POSITION_MIN ) );
2767   mScrollMainInternalRelativeConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::SCROLL_POSITION_MAX ) );
2768   mScrollMainInternalRelativeConstraint.AddSource( LocalSource( Actor::Property::SIZE ) );
2769   mScrollMainInternalRelativeConstraint.Apply();
2770
2771   mScrollMainInternalDomainConstraint = Constraint::New<Vector2>( self, Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE, InternalScrollDomainConstraint );
2772   mScrollMainInternalDomainConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::SCROLL_POSITION_MIN ) );
2773   mScrollMainInternalDomainConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::SCROLL_POSITION_MAX ) );
2774   mScrollMainInternalDomainConstraint.AddSource( LocalSource( Actor::Property::SIZE ) );
2775   mScrollMainInternalDomainConstraint.Apply();
2776
2777   mScrollMainInternalPrePositionMaxConstraint = Constraint::New<Vector2>( self, Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX, InternalPrePositionMaxConstraint );
2778   mScrollMainInternalPrePositionMaxConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::SCROLL_POSITION_MAX ) );
2779   mScrollMainInternalPrePositionMaxConstraint.AddSource( LocalSource( Actor::Property::SIZE ) );
2780   mScrollMainInternalPrePositionMaxConstraint.Apply();
2781
2782   // When panning we want to make sure overshoot values are affected by pre position and post position
2783   SetOvershootConstraintsEnabled(!mWrapMode);
2784 }
2785
2786 void ScrollView::SetOvershootConstraintsEnabled(bool enabled)
2787 {
2788   Actor self( Self() );
2789   // remove and reset, it may now be in wrong order with the main internal constraints
2790   if( mScrollMainInternalOvershootXConstraint )
2791   {
2792     mScrollMainInternalOvershootXConstraint.Remove();
2793     mScrollMainInternalOvershootXConstraint.Reset();
2794     mScrollMainInternalOvershootYConstraint.Remove();
2795     mScrollMainInternalOvershootYConstraint.Reset();
2796   }
2797   if( enabled )
2798   {
2799     mScrollMainInternalOvershootXConstraint= Constraint::New<float>( self, Toolkit::ScrollView::Property::OVERSHOOT_X, OvershootXConstraint(mMaxOvershoot.x) );
2800     mScrollMainInternalOvershootXConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ) );
2801     mScrollMainInternalOvershootXConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_POSITION ) );
2802     mScrollMainInternalOvershootXConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL ) );
2803     mScrollMainInternalOvershootXConstraint.Apply();
2804
2805     mScrollMainInternalOvershootYConstraint = Constraint::New<float>( self, Toolkit::ScrollView::Property::OVERSHOOT_Y, OvershootYConstraint(mMaxOvershoot.y) );
2806     mScrollMainInternalOvershootYConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_PRE_POSITION ) );
2807     mScrollMainInternalOvershootYConstraint.AddSource( LocalSource( Toolkit::ScrollView::Property::SCROLL_POSITION ) );
2808     mScrollMainInternalOvershootYConstraint.AddSource( LocalSource( Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL ) );
2809     mScrollMainInternalOvershootYConstraint.Apply();
2810   }
2811   else
2812   {
2813     self.SetProperty(Toolkit::ScrollView::Property::OVERSHOOT_X, 0.0f);
2814     self.SetProperty(Toolkit::ScrollView::Property::OVERSHOOT_Y, 0.0f);
2815   }
2816 }
2817
2818 void ScrollView::SetInternalConstraints()
2819 {
2820   // Internal constraints (applied to target ScrollBase Actor itself) /////////
2821   UpdateMainInternalConstraint();
2822
2823   // User definable constraints to apply to all child actors //////////////////
2824   Actor self = Self();
2825
2826   // Apply some default constraints to ScrollView & its bound actors
2827   // Movement + Wrap function
2828
2829   Constraint constraint;
2830
2831   // MoveActor (scrolling)
2832   constraint = Constraint::New<Vector3>( self, Actor::Property::POSITION, MoveActorConstraint );
2833   constraint.AddSource( Source( self, Toolkit::ScrollView::Property::SCROLL_POSITION ) );
2834   constraint.SetRemoveAction(Constraint::Discard);
2835   ApplyConstraintToBoundActors(constraint);
2836
2837   // WrapActor (wrap functionality)
2838   constraint = Constraint::New<Vector3>( self, Actor::Property::POSITION, WrapActorConstraint );
2839   constraint.AddSource( LocalSource( Actor::Property::SCALE ) );
2840   constraint.AddSource( LocalSource( Actor::Property::ANCHOR_POINT ) );
2841   constraint.AddSource( LocalSource( Actor::Property::SIZE ) );
2842   constraint.AddSource( Source( self, Toolkit::Scrollable::Property::SCROLL_POSITION_MIN ) );
2843   constraint.AddSource( Source( self, Toolkit::Scrollable::Property::SCROLL_POSITION_MAX ) );
2844   constraint.AddSource( Source( self, Toolkit::ScrollView::Property::WRAP ) );
2845   constraint.SetRemoveAction(Constraint::Discard);
2846   ApplyConstraintToBoundActors(constraint);
2847 }
2848
2849 void ScrollView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
2850 {
2851   Toolkit::ScrollView scrollView = Toolkit::ScrollView::DownCast( Dali::BaseHandle( object ) );
2852
2853   if( scrollView )
2854   {
2855     ScrollView& scrollViewImpl( GetImpl( scrollView ) );
2856     switch( index )
2857     {
2858       case Toolkit::ScrollView::Property::WRAP_ENABLED:
2859       {
2860         scrollViewImpl.SetWrapMode( value.Get<bool>() );
2861         break;
2862       }
2863       case Toolkit::ScrollView::Property::PANNING_ENABLED:
2864       {
2865         scrollViewImpl.SetScrollSensitive( value.Get<bool>() );
2866         break;
2867       }
2868       case Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED:
2869       {
2870         scrollViewImpl.SetAxisAutoLock( value.Get<bool>() );
2871         break;
2872       }
2873       case Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP:
2874       {
2875         scrollViewImpl.SetWheelScrollDistanceStep( value.Get<Vector2>() );
2876         break;
2877       }
2878     }
2879   }
2880 }
2881
2882 Property::Value ScrollView::GetProperty( BaseObject* object, Property::Index index )
2883 {
2884   Property::Value value;
2885
2886   Toolkit::ScrollView scrollView = Toolkit::ScrollView::DownCast( Dali::BaseHandle( object ) );
2887
2888   if( scrollView )
2889   {
2890     ScrollView& scrollViewImpl( GetImpl( scrollView ) );
2891     switch( index )
2892     {
2893       case Toolkit::ScrollView::Property::WRAP_ENABLED:
2894       {
2895         value = scrollViewImpl.GetWrapMode();
2896         break;
2897       }
2898       case Toolkit::ScrollView::Property::PANNING_ENABLED:
2899       {
2900         value = scrollViewImpl.GetScrollSensitive();
2901         break;
2902       }
2903       case Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED:
2904       {
2905         value = scrollViewImpl.GetAxisAutoLock();
2906         break;
2907       }
2908       case Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP:
2909       {
2910         value = scrollViewImpl.GetWheelScrollDistanceStep();
2911         break;
2912       }
2913     }
2914   }
2915
2916   return value;
2917 }
2918
2919 } // namespace Internal
2920
2921 } // namespace Toolkit
2922
2923 } // namespace Dali