base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.cpp

   1 /*
   2  * Copyright (c) 2014 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/item-view/item-view-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/events/mouse-wheel-event.h>
  26 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-factory.h>
  27 #include <dali-toolkit/internal/controls/scrollable/scroll-connector-impl.h>
  28 #include <dali-toolkit/internal/controls/scrollable/bouncing-effect-actor.h>
  29
  30 using namespace std;
  31 using namespace Dali;
  32
  33 namespace // unnamed namespace
  34 {
  35
  36 //Type registration
  37 TypeRegistration mType( typeid(Toolkit::ItemView), typeid(Toolkit::Scrollable), NULL );
  38
  39 const float DEFAULT_MINIMUM_SWIPE_SPEED = 1.0f;
  40 const float DEFAULT_MINIMUM_SWIPE_DISTANCE = 3.0f;
  41 const float DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION = 0.1f;
  42
  43 const float DEFAULT_REFRESH_INTERVAL_LAYOUT_POSITIONS = 20.0f; // 1 updates per 20 items
  44 const int MOUSE_WHEEL_EVENT_FINISHED_TIME_OUT = 500;  // 0.5 second
  45
  46 const float DEFAULT_ANCHORING_DURATION = 1.0f;  // 1 second
  47 const float DEFAULT_COLOR_VISIBILITY_REMOVE_TIME = 0.5f; // 0.5 second
  48
  49 const float MILLISECONDS_PER_SECONDS = 1000.0f;
  50
  51 const Vector2 OVERSHOOT_BOUNCE_ACTOR_DEFAULT_SIZE( 720.0f, 42.0f );
  52 const float OVERSHOOT_BOUNCE_ACTOR_RESIZE_THRESHOLD = 180.0f;
  53 const Vector4 OVERSHOOT_OVERLAY_NINE_PATCH_BORDER(0.0f, 0.0f, 1.0f, 12.0f);
  54 const float MAXIMUM_OVERSHOOT_HEIGHT = 36.0f;  // 36 pixels
  55 const float DEFAULT_OVERSHOOT_ANIMATION_DURATION = 0.5f;  // 0.5 second
  56 const float DEFAULT_KEYBOARD_FOCUS_SCROLL_DURATION = 0.2f;
  57
  58 const string LAYOUT_POSITION_PROPERTY_NAME( "item-view-layout-position" );
  59 const string POSITION_PROPERTY_NAME( "item-view-position" );
  60 const string MINIMUM_LAYOUT_POSITION_PROPERTY_NAME( "item-view-minimum-layout-position" );
  61 const string SCROLL_SPEED_PROPERTY_NAME( "item-view-scroll-speed" );
  62 const string SCROLL_DIRECTION_PROPERTY_NAME( "item-view-scroll-direction" );
  63 const string OVERSHOOT_PROPERTY_NAME( "item-view-overshoot" );
  64
  65 // Functors which wrap constraint functions with stored item IDs
  66
  67 struct WrappedVector3Constraint
  68 {
  69   WrappedVector3Constraint(Toolkit::ItemLayout::Vector3Function wrapMe, unsigned int itemId)
  70   : mWrapMe(wrapMe),
  71     mItemId(itemId)
  72   {
  73   }
  74
  75   Vector3 operator()(const Vector3& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
  76   {
  77     float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
  78
  79     return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
  80   }
  81
  82   Toolkit::ItemLayout::Vector3Function mWrapMe;
  83   unsigned int mItemId;
  84 };
  85
  86 struct WrappedQuaternionConstraint
  87 {
  88   WrappedQuaternionConstraint(Toolkit::ItemLayout::QuaternionFunction wrapMe, unsigned int itemId)
  89   : mWrapMe(wrapMe),
  90     mItemId(itemId)
  91   {
  92   }
  93
  94   Quaternion operator()(const Quaternion& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
  95   {
  96     float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
  97
  98     return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
  99   }
 100
 101   Toolkit::ItemLayout::QuaternionFunction mWrapMe;
 102   unsigned int mItemId;
 103 };
 104
 105 struct WrappedVector4Constraint
 106 {
 107   WrappedVector4Constraint(Toolkit::ItemLayout::Vector4Function wrapMe, unsigned int itemId)
 108   : mWrapMe(wrapMe),
 109     mItemId(itemId)
 110   {
 111   }
 112
 113   Vector4 operator()(const Vector4& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
 114   {
 115     float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
 116
 117     return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
 118   }
 119
 120   Toolkit::ItemLayout::Vector4Function mWrapMe;
 121   unsigned int mItemId;
 122 };
 123
 124 struct WrappedBoolConstraint
 125 {
 126   WrappedBoolConstraint(Toolkit::ItemLayout::BoolFunction wrapMe, unsigned int itemId)
 127   : mWrapMe(wrapMe),
 128     mItemId(itemId)
 129   {
 130   }
 131
 132   bool operator()(const bool& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
 133   {
 134     float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
 135
 136     return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
 137   }
 138
 139   Toolkit::ItemLayout::BoolFunction mWrapMe;
 140   unsigned int mItemId;
 141 };
 142
 143 /**
 144  * Local helper to convert pan distance (in actor coordinates) to the layout-specific scrolling direction
 145  */
 146 float CalculateScrollDistance(Vector2 panDistance, Toolkit::ItemLayout& layout)
 147 {
 148   Radian scrollDirection(layout.GetScrollDirection());
 149
 150   float cosTheta = cosf(scrollDirection);
 151   float sinTheta = sinf(scrollDirection);
 152
 153   return panDistance.x * sinTheta + panDistance.y * cosTheta;
 154 }
 155
 156 // Overshoot overlay constraints
 157
 158 struct OvershootOverlaySizeConstraint
 159 {
 160   Vector3 operator()(const Vector3& current,
 161                      const PropertyInput& parentScrollDirectionProperty,
 162                      const PropertyInput& parentOvershootProperty,
 163                      const PropertyInput& parentSizeProperty)
 164   {
 165     const Vector3 parentScrollDirection = parentScrollDirectionProperty.GetVector3();
 166     const Vector3 parentSize = parentSizeProperty.GetVector3();
 167     const Toolkit::ControlOrientation::Type& parentOrientation = static_cast<Toolkit::ControlOrientation::Type>(parentScrollDirection.z);
 168
 169     float overlayWidth;
 170
 171     if(Toolkit::IsVertical(parentOrientation))
 172     {
 173       overlayWidth = fabsf(parentScrollDirection.y) > Math::MACHINE_EPSILON_1 ? parentSize.x : parentSize.y;
 174     }
 175     else
 176     {
 177       overlayWidth = fabsf(parentScrollDirection.x) > Math::MACHINE_EPSILON_1 ? parentSize.y : parentSize.x;
 178     }
 179
 180     float overlayHeight = (overlayWidth > OVERSHOOT_BOUNCE_ACTOR_RESIZE_THRESHOLD) ? OVERSHOOT_BOUNCE_ACTOR_DEFAULT_SIZE.height : OVERSHOOT_BOUNCE_ACTOR_DEFAULT_SIZE.height*0.5f;
 181
 182     return Vector3( overlayWidth, overlayHeight, current.depth );
 183   }
 184 };
 185
 186 struct OvershootOverlayRotationConstraint
 187 {
 188   Quaternion operator()(const Quaternion& current,
 189                         const PropertyInput& parentScrollDirectionProperty,
 190                         const PropertyInput& parentOvershootProperty)
 191   {
 192     const Vector3 parentScrollDirection = parentScrollDirectionProperty.GetVector3();
 193     const float parentOvershoot = parentOvershootProperty.GetFloat();
 194     const Toolkit::ControlOrientation::Type& parentOrientation = static_cast<Toolkit::ControlOrientation::Type>(parentScrollDirection.z);
 195
 196     Quaternion rotation;
 197
 198     if(Toolkit::IsVertical(parentOrientation))
 199     {
 200       if(fabsf(parentScrollDirection.y) <= Math::MACHINE_EPSILON_1)
 201       {
 202         if( (parentOrientation == Toolkit::ControlOrientation::Up && parentOvershoot < Math::MACHINE_EPSILON_0)
 203             || (parentOrientation == Toolkit::ControlOrientation::Down && parentOvershoot > Math::MACHINE_EPSILON_0) )
 204         {
 205           rotation = Quaternion(0.5f * Math::PI, Vector3::ZAXIS);
 206         }
 207         else
 208         {
 209           rotation = Quaternion(1.5f * Math::PI, Vector3::ZAXIS);
 210         }
 211       }
 212       else if( (parentOvershoot > Math::MACHINE_EPSILON_0 && parentScrollDirection.y > Math::MACHINE_EPSILON_0)
 213             || (parentOvershoot < Math::MACHINE_EPSILON_0 && parentScrollDirection.y < Math::MACHINE_EPSILON_0) )
 214       {
 215         rotation = Quaternion(0.0f, Vector3::ZAXIS);
 216       }
 217       else
 218       {
 219         rotation = Quaternion(Math::PI, Vector3::ZAXIS);
 220       }
 221     }
 222     else
 223     {
 224       if(fabsf(parentScrollDirection.x) <= Math::MACHINE_EPSILON_1)
 225       {
 226         if( (parentOrientation == Toolkit::ControlOrientation::Left && parentOvershoot > Math::MACHINE_EPSILON_0)
 227             ||(parentOrientation == Toolkit::ControlOrientation::Right && parentOvershoot < Math::MACHINE_EPSILON_0) )
 228         {
 229           rotation = Quaternion(Math::PI, Vector3::ZAXIS);
 230         }
 231         else
 232         {
 233           rotation = Quaternion(0.0f, Vector3::ZAXIS);
 234         }
 235       }
 236       else if( (parentOvershoot > Math::MACHINE_EPSILON_0 && parentScrollDirection.x > Math::MACHINE_EPSILON_0)
 237             || (parentOvershoot < Math::MACHINE_EPSILON_0 && parentScrollDirection.x < Math::MACHINE_EPSILON_0) )
 238       {
 239         rotation = Quaternion(1.5f * Math::PI, Vector3::ZAXIS);
 240       }
 241       else
 242       {
 243         rotation = Quaternion(0.5f * Math::PI, Vector3::ZAXIS);
 244       }
 245     }
 246
 247     return rotation;
 248   }
 249 };
 250
 251 struct OvershootOverlayPositionConstraint
 252 {
 253   Vector3 operator()(const Vector3&    current,
 254                      const PropertyInput& parentSizeProperty,
 255                      const PropertyInput& parentScrollDirectionProperty,
 256                      const PropertyInput& parentOvershootProperty)
 257   {
 258     const Vector3 parentScrollDirection = parentScrollDirectionProperty.GetVector3();
 259     const float parentOvershoot = parentOvershootProperty.GetFloat();
 260     const Vector3 parentSize = parentSizeProperty.GetVector3();
 261     const Toolkit::ControlOrientation::Type& parentOrientation = static_cast<Toolkit::ControlOrientation::Type>(parentScrollDirection.z);
 262
 263     Vector3 relativeOffset;
 264
 265     if(Toolkit::IsVertical(parentOrientation))
 266     {
 267       if(fabsf(parentScrollDirection.y) <= Math::MACHINE_EPSILON_1)
 268       {
 269         if( (parentOrientation == Toolkit::ControlOrientation::Up && parentOvershoot < Math::MACHINE_EPSILON_0)
 270             || (parentOrientation == Toolkit::ControlOrientation::Down && parentOvershoot > Math::MACHINE_EPSILON_0) )
 271         {
 272           relativeOffset = Vector3(1.0f, 0.0f, 0.0f);
 273         }
 274         else
 275         {
 276           relativeOffset =Vector3(0.0f, 1.0f, 0.0f);
 277         }
 278       }
 279       else if( (parentOvershoot > Math::MACHINE_EPSILON_0 && parentScrollDirection.y > Math::MACHINE_EPSILON_0)
 280             || (parentOvershoot < Math::MACHINE_EPSILON_0 && parentScrollDirection.y < Math::MACHINE_EPSILON_0) )
 281       {
 282         relativeOffset = Vector3(0.0f, 0.0f, 0.0f);
 283       }
 284       else
 285       {
 286         relativeOffset = Vector3(1.0f, 1.0f, 0.0f);
 287       }
 288     }
 289     else
 290     {
 291       if(fabsf(parentScrollDirection.x) <= Math::MACHINE_EPSILON_1)
 292       {
 293         if( (parentOrientation == Toolkit::ControlOrientation::Left && parentOvershoot < Math::MACHINE_EPSILON_0)
 294             || (parentOrientation == Toolkit::ControlOrientation::Right && parentOvershoot > Math::MACHINE_EPSILON_0) )
 295         {
 296           relativeOffset = Vector3(0.0f, 0.0f, 0.0f);
 297         }
 298         else
 299         {
 300           relativeOffset = Vector3(1.0f, 1.0f, 0.0f);
 301         }
 302       }
 303       else if( (parentOvershoot > Math::MACHINE_EPSILON_0 && parentScrollDirection.x > Math::MACHINE_EPSILON_0)
 304             || (parentOvershoot < Math::MACHINE_EPSILON_0 && parentScrollDirection.x < Math::MACHINE_EPSILON_0) )
 305       {
 306         relativeOffset = Vector3(0.0f, 1.0f, 0.0f);
 307       }
 308       else
 309       {
 310         relativeOffset = Vector3(1.0f, 0.0f, 0.0f);
 311       }
 312     }
 313
 314     return relativeOffset * parentSize;
 315
 316   }
 317 };
 318
 319 struct OvershootOverlayVisibilityConstraint
 320 {
 321   bool operator()(const bool& current,
 322                   const PropertyInput& parentLayoutScrollableProperty)
 323   {
 324     const bool parentLayoutScrollable = parentLayoutScrollableProperty.GetBoolean();
 325
 326     return parentLayoutScrollable;
 327   }
 328 };
 329
 330 /**
 331  * Relative position Constraint
 332  * Generates the relative position value of the item view based on the layout position,
 333  * and it's relation to the layout domain. This is a value from 0.0f to 1.0f in each axis.
 334  */
 335 Vector3 RelativePositionConstraint(const Vector3& current,
 336                                    const PropertyInput& scrollPositionProperty,
 337                                    const PropertyInput& scrollMinProperty,
 338                                    const PropertyInput& scrollMaxProperty,
 339                                    const PropertyInput& layoutSizeProperty)
 340 {
 341   const Vector3& position = Vector3(0.0f, scrollPositionProperty.GetFloat(), 0.0f);
 342   const Vector3& min = scrollMinProperty.GetVector3();
 343   const Vector3& max = scrollMaxProperty.GetVector3();
 344
 345   Vector3 relativePosition;
 346   Vector3 domainSize = max - min;
 347
 348   relativePosition.x = fabsf(domainSize.x) > Math::MACHINE_EPSILON_1 ? ((min.x - position.x) / fabsf(domainSize.x)) : 0.0f;
 349   relativePosition.y = fabsf(domainSize.y) > Math::MACHINE_EPSILON_1 ? ((min.y - position.y) / fabsf(domainSize.y)) : 0.0f;
 350
 351   return relativePosition;
 352 }
 353
 354 } // unnamed namespace
 355
 356 namespace Dali
 357 {
 358
 359 namespace Toolkit
 360 {
 361
 362 namespace Internal
 363 {
 364
 365 namespace // unnamed namespace
 366 {
 367
 368 bool FindById( const ItemContainer& items, ItemId id )
 369 {
 370   for( ConstItemIter iter = items.begin(); items.end() != iter; ++iter )
 371   {
 372     if( iter->first == id )
 373     {
 374       return true;
 375     }
 376   }
 377
 378   return false;
 379 }
 380
 381 } // unnamed namespace
 382
 383 Dali::Toolkit::ItemView ItemView::New(ItemFactory& factory)
 384 {
 385   // Create the implementation
 386   ItemViewPtr itemView(new ItemView(factory));
 387
 388   // Pass ownership to CustomActor via derived handle
 389   Dali::Toolkit::ItemView handle(*itemView);
 390
 391   // Second-phase init of the implementation
 392   // This can only be done after the CustomActor connection has been made...
 393   itemView->Initialize();
 394
 395   return handle;
 396 }
 397
 398 ItemView::ItemView(ItemFactory& factory)
 399 : Scrollable(),
 400   mItemFactory(factory),
 401   mActiveLayout(NULL),
 402   mDefaultAlphaFunction(Dali::Constraint::DEFAULT_ALPHA_FUNCTION),
 403   mAnimatingOvershootOn(false),
 404   mAnimateOvershootOff(false),
 405   mAnchoringEnabled(true),
 406   mAnchoringDuration(DEFAULT_ANCHORING_DURATION),
 407   mRefreshIntervalLayoutPositions(DEFAULT_REFRESH_INTERVAL_LAYOUT_POSITIONS),
 408   mRefreshOrderHint(true/*Refresh item 0 first*/),
 409   mMinimumSwipeSpeed(DEFAULT_MINIMUM_SWIPE_SPEED),
 410   mMinimumSwipeDistance(DEFAULT_MINIMUM_SWIPE_DISTANCE),
 411   mScrollDistance(0.0f),
 412   mScrollSpeed(0.0f),
 413   mTotalPanDisplacement(Vector2::ZERO),
 414   mScrollOvershoot(0.0f),
 415   mIsFlicking(false),
 416   mGestureState(Gesture::Clear),
 417   mAddingItems(false),
 418   mRefreshEnabled(true),
 419   mItemsParentOrigin( ParentOrigin::CENTER),
 420   mItemsAnchorPoint( AnchorPoint::CENTER)
 421 {
 422   SetRequiresMouseWheelEvents(true);
 423   SetKeyboardNavigationSupport(true);
 424 }
 425
 426 void ItemView::OnInitialize()
 427 {
 428   SetSizePolicy( Toolkit::Control::Fixed, Toolkit::Control::Fixed );
 429
 430   RegisterCommonProperties();
 431
 432   Actor self = Self();
 433
 434   mScrollConnector = Dali::Toolkit::ScrollConnector::New();
 435   mScrollPositionObject = mScrollConnector.GetScrollPositionObject();
 436
 437   mPropertyMinimumLayoutPosition = self.RegisterProperty(MINIMUM_LAYOUT_POSITION_PROPERTY_NAME, 0.0f);
 438   mPropertyPosition = self.RegisterProperty(POSITION_PROPERTY_NAME, 0.0f);
 439   mPropertyScrollSpeed = self.RegisterProperty(SCROLL_SPEED_PROPERTY_NAME, 0.0f);
 440
 441   EnableScrollComponent(Toolkit::Scrollable::OvershootIndicator);
 442
 443   Constraint constraint = Constraint::New<Vector3>(mPropertyRelativePosition,
 444                                                    LocalSource(mPropertyPosition),
 445                                                    LocalSource(mPropertyPositionMin),
 446                                                    LocalSource(mPropertyPositionMax),
 447                                                    LocalSource(Actor::SIZE),
 448                                                    RelativePositionConstraint);
 449   self.ApplyConstraint(constraint);
 450
 451   Vector2 stageSize = Stage::GetCurrent().GetSize();
 452   mMouseWheelScrollDistanceStep = stageSize.y * DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION;
 453
 454   EnableGestureDetection(Gesture::Type(Gesture::Pan));
 455
 456   mMouseWheelEventFinishedTimer = Timer::New( MOUSE_WHEEL_EVENT_FINISHED_TIME_OUT );
 457   mMouseWheelEventFinishedTimer.TickSignal().Connect( this, &ItemView::OnMouseWheelEventFinished );
 458
 459   SetRefreshInterval(mRefreshIntervalLayoutPositions);
 460 }
 461
 462 ItemView::~ItemView()
 463 {
 464 }
 465
 466 Dali::Toolkit::ScrollConnector ItemView::GetScrollConnector() const
 467 {
 468   return mScrollConnector;
 469 }
 470
 471 unsigned int ItemView::GetLayoutCount() const
 472 {
 473   return mLayouts.size();
 474 }
 475
 476 void ItemView::AddLayout(ItemLayout& layout)
 477 {
 478   mLayouts.push_back(ItemLayoutPtr(&layout));
 479 }
 480
 481 void ItemView::RemoveLayout(unsigned int layoutIndex)
 482 {
 483   DALI_ASSERT_ALWAYS(layoutIndex < mLayouts.size());
 484
 485   if (mActiveLayout == mLayouts[layoutIndex].Get())
 486   {
 487     mActiveLayout = NULL;
 488   }
 489
 490   mLayouts.erase(mLayouts.begin() + layoutIndex);
 491 }
 492
 493 ItemLayoutPtr ItemView::GetLayout(unsigned int layoutIndex) const
 494 {
 495   return mLayouts[layoutIndex];
 496 }
 497
 498 ItemLayoutPtr ItemView::GetActiveLayout() const
 499 {
 500   return ItemLayoutPtr(mActiveLayout);
 501 }
 502
 503 float ItemView::GetCurrentLayoutPosition(unsigned int itemId) const
 504 {
 505   return mScrollPositionObject.GetProperty<float>( ScrollConnector::SCROLL_POSITION ) + static_cast<float>( itemId );
 506 }
 507
 508 void ItemView::ActivateLayout(unsigned int layoutIndex, const Vector3& targetSize, float durationSeconds)
 509 {
 510   DALI_ASSERT_ALWAYS(layoutIndex < mLayouts.size());
 511
 512   Actor self = Self();
 513
 514   // The ItemView size should match the active layout size
 515   self.SetSize(targetSize);
 516   mActiveLayoutTargetSize = targetSize;
 517
 518   // Switch to the new layout
 519   mActiveLayout = mLayouts[layoutIndex].Get();
 520
 521   // Move the items to the new layout positions...
 522
 523   bool resizeAnimationNeeded(false);
 524
 525   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
 526   {
 527     unsigned int itemId = iter->first;
 528     Actor actor = iter->second;
 529
 530     // Remove constraints from previous layout
 531     actor.RemoveConstraints();
 532
 533     Vector3 size;
 534     if(mActiveLayout->GetItemSize(itemId, targetSize, size))
 535     {
 536       if( durationSeconds > 0.0f )
 537       {
 538         // Use a size animation
 539         if (!resizeAnimationNeeded)
 540         {
 541           resizeAnimationNeeded = true;
 542           RemoveAnimation(mResizeAnimation);
 543           mResizeAnimation = Animation::New(durationSeconds);
 544         }
 545
 546         // The layout provides its own resize animation
 547         mActiveLayout->GetResizeAnimation(mResizeAnimation, actor, size, durationSeconds);
 548       }
 549       else
 550       {
 551         // resize immediately
 552         actor.SetSize(size);
 553       }
 554     }
 555
 556     ApplyConstraints(actor, *mActiveLayout, itemId, durationSeconds);
 557   }
 558
 559   if (resizeAnimationNeeded)
 560   {
 561     mResizeAnimation.Play();
 562   }
 563
 564   // Refresh the new layout
 565   ItemRange range = GetItemRange(*mActiveLayout, targetSize, GetCurrentLayoutPosition(0), true/*reserve extra*/);
 566   AddActorsWithinRange( range, durationSeconds );
 567
 568   // Scroll to an appropriate layout position
 569
 570   bool scrollAnimationNeeded(false);
 571   float firstItemScrollPosition(0.0f);
 572
 573   float current = GetCurrentLayoutPosition(0);
 574   float minimum = ClampFirstItemPosition(current, targetSize, *mActiveLayout);
 575   self.SetProperty(mPropertyPosition, GetScrollPosition(current, targetSize));
 576
 577   if (current < minimum)
 578   {
 579     scrollAnimationNeeded = true;
 580     firstItemScrollPosition = minimum;
 581   }
 582   else if (mAnchoringEnabled)
 583   {
 584     scrollAnimationNeeded = true;
 585     firstItemScrollPosition = mActiveLayout->GetClosestAnchorPosition(current);
 586   }
 587
 588   if (scrollAnimationNeeded)
 589   {
 590     RemoveAnimation(mScrollAnimation);
 591     mScrollAnimation = Animation::New(durationSeconds);
 592     mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
 593     mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, targetSize), AlphaFunctions::EaseOut );
 594     mScrollAnimation.Play();
 595   }
 596
 597   self.SetProperty(mPropertyMinimumLayoutPosition, mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), targetSize));
 598   AnimateScrollOvershoot(0.0f);
 599   mScrollOvershoot = 0.0f;
 600
 601   Radian scrollDirection(mActiveLayout->GetScrollDirection());
 602   float orientation = static_cast<float>(mActiveLayout->GetOrientation());
 603   self.SetProperty(mPropertyScrollDirection, Vector3(sinf(scrollDirection), cosf(scrollDirection), orientation));
 604
 605   self.SetProperty(mPropertyScrollSpeed, mScrollSpeed);
 606
 607   CalculateDomainSize(targetSize);
 608 }
 609
 610 void ItemView::DeactivateCurrentLayout()
 611 {
 612   if (mActiveLayout)
 613   {
 614     for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
 615     {
 616       Actor actor = iter->second;
 617       actor.RemoveConstraints();
 618     }
 619
 620     mActiveLayout = NULL;
 621   }
 622 }
 623
 624 void ItemView::SetDefaultAlphaFunction(AlphaFunction func)
 625 {
 626   mDefaultAlphaFunction = func;
 627 }
 628
 629 AlphaFunction ItemView::GetDefaultAlphaFunction() const
 630 {
 631   return mDefaultAlphaFunction;
 632 }
 633
 634 void ItemView::OnRefreshNotification(PropertyNotification& source)
 635 {
 636   if(mRefreshEnabled)
 637   {
 638     // Only refresh the cache during normal scrolling
 639     DoRefresh(GetCurrentLayoutPosition(0), true);
 640   }
 641 }
 642
 643 void ItemView::DoRefresh(float currentLayoutPosition, bool cacheExtra)
 644 {
 645   if (mActiveLayout)
 646   {
 647     ItemRange range = GetItemRange(*mActiveLayout, mActiveLayoutTargetSize, currentLayoutPosition, cacheExtra/*reserve extra*/);
 648     RemoveActorsOutsideRange( range );
 649     AddActorsWithinRange( range, 0.0f/*immediate*/ );
 650
 651     mScrollUpdatedSignalV2.Emit( Vector3(0.0f, currentLayoutPosition, 0.0f) );
 652   }
 653 }
 654
 655 void ItemView::SetMinimumSwipeSpeed(float speed)
 656 {
 657   mMinimumSwipeSpeed = speed;
 658 }
 659
 660 float ItemView::GetMinimumSwipeSpeed() const
 661 {
 662   return mMinimumSwipeSpeed;
 663 }
 664
 665 void ItemView::SetMinimumSwipeDistance(float distance)
 666 {
 667   mMinimumSwipeDistance = distance;
 668 }
 669
 670 float ItemView::GetMinimumSwipeDistance() const
 671 {
 672   return mMinimumSwipeDistance;
 673 }
 674
 675 void ItemView::SetMouseWheelScrollDistanceStep(float step)
 676 {
 677   mMouseWheelScrollDistanceStep = step;
 678 }
 679
 680 float ItemView::GetMouseWheelScrollDistanceStep() const
 681 {
 682   return mMouseWheelScrollDistanceStep;
 683 }
 684
 685 void ItemView::SetAnchoring(bool enabled)
 686 {
 687   mAnchoringEnabled = enabled;
 688 }
 689
 690 bool ItemView::GetAnchoring() const
 691 {
 692   return mAnchoringEnabled;
 693 }
 694
 695 void ItemView::SetAnchoringDuration(float durationSeconds)
 696 {
 697   mAnchoringDuration = durationSeconds;
 698 }
 699
 700 float ItemView::GetAnchoringDuration() const
 701 {
 702   return mAnchoringDuration;
 703 }
 704
 705 void ItemView::SetRefreshInterval(float intervalLayoutPositions)
 706 {
 707   mRefreshIntervalLayoutPositions = intervalLayoutPositions;
 708
 709   if(mRefreshNotification)
 710   {
 711     mScrollPositionObject.RemovePropertyNotification(mRefreshNotification);
 712   }
 713   mRefreshNotification = mScrollPositionObject.AddPropertyNotification( ScrollConnector::SCROLL_POSITION, StepCondition(mRefreshIntervalLayoutPositions, 0.0f) );
 714   mRefreshNotification.NotifySignal().Connect( this, &ItemView::OnRefreshNotification );
 715 }
 716
 717 float ItemView::GetRefreshInterval() const
 718 {
 719   return mRefreshIntervalLayoutPositions;
 720 }
 721
 722 void ItemView::SetRefreshEnabled(bool enabled)
 723 {
 724   mRefreshEnabled = enabled;
 725 }
 726
 727 Actor ItemView::GetItem(unsigned int itemId) const
 728 {
 729   Actor actor;
 730
 731   ConstItemPoolIter iter = mItemPool.find( itemId );
 732   if( iter != mItemPool.end() )
 733   {
 734     actor = iter->second;
 735   }
 736
 737   return actor;
 738 }
 739
 740 unsigned int ItemView::GetItemId( Actor actor ) const
 741 {
 742   unsigned int itemId( 0 );
 743
 744   for ( ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter )
 745   {
 746     if( iter->second == actor )
 747     {
 748       itemId = iter->first;
 749       break;
 750     }
 751   }
 752
 753   return itemId;
 754 }
 755
 756 void ItemView::InsertItem( Item newItem, float durationSeconds )
 757 {
 758   mAddingItems = true;
 759
 760   SetupActor( newItem, durationSeconds );
 761   Self().Add( newItem.second );
 762
 763   ItemPoolIter foundIter = mItemPool.find( newItem.first );
 764   if( mItemPool.end() != foundIter )
 765   {
 766     Actor moveMe = foundIter->second;
 767     foundIter->second = newItem.second;
 768
 769     // Move the existing actors to make room
 770     for( ItemPoolIter iter = ++foundIter; mItemPool.end() != iter; ++iter )
 771     {
 772       Actor temp = iter->second;
 773       iter->second = moveMe;
 774       moveMe = temp;
 775
 776       iter->second.RemoveConstraints();
 777       ApplyConstraints( iter->second, *mActiveLayout, iter->first, durationSeconds );
 778     }
 779
 780     // Create last item
 781     ItemId lastId = mItemPool.rbegin()->first;
 782     Item lastItem( lastId + 1, moveMe );
 783     mItemPool.insert( lastItem );
 784
 785     lastItem.second.RemoveConstraints();
 786     ApplyConstraints( lastItem.second, *mActiveLayout, lastItem.first, durationSeconds );
 787   }
 788   else
 789   {
 790     mItemPool.insert( newItem );
 791   }
 792
 793   CalculateDomainSize(Self().GetCurrentSize());
 794
 795   mAddingItems = false;
 796 }
 797
 798 void ItemView::InsertItems( const ItemContainer& newItems, float durationSeconds )
 799 {
 800   mAddingItems = true;
 801
 802   // Insert from lowest id to highest
 803   set<Item> sortedItems;
 804   for( ConstItemIter iter = newItems.begin(); newItems.end() != iter; ++iter )
 805   {
 806     sortedItems.insert( *iter );
 807   }
 808
 809   for( set<Item>::iterator iter = sortedItems.begin(); sortedItems.end() != iter; ++iter )
 810   {
 811     Self().Add( iter->second );
 812
 813     cout << "inserting item: " << iter->first << endl;
 814
 815     ItemPoolIter foundIter = mItemPool.find( iter->first );
 816     if( mItemPool.end() != foundIter )
 817     {
 818       Actor moveMe = foundIter->second;
 819       foundIter->second = iter->second;
 820
 821       // Move the existing actors to make room
 822       for( ItemPoolIter iter = ++foundIter; mItemPool.end() != iter; ++iter )
 823       {
 824         Actor temp = iter->second;
 825         iter->second = moveMe;
 826         moveMe = temp;
 827       }
 828
 829       // Create last item
 830       ItemId lastId = mItemPool.rbegin()->first;
 831       Item lastItem( lastId + 1, moveMe );
 832       mItemPool.insert( lastItem );
 833     }
 834     else
 835     {
 836       mItemPool.insert( *iter );
 837     }
 838   }
 839
 840   // Relayout everything
 841   for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
 842   {
 843     // If newly inserted
 844     if( FindById( newItems, iter->first ) )
 845     {
 846       SetupActor( *iter, durationSeconds );
 847     }
 848     else
 849     {
 850       iter->second.RemoveConstraints();
 851       ApplyConstraints( iter->second, *mActiveLayout, iter->first, durationSeconds );
 852     }
 853   }
 854
 855   CalculateDomainSize(Self().GetCurrentSize());
 856
 857   mAddingItems = false;
 858 }
 859
 860 void ItemView::RemoveItem( unsigned int itemId, float durationSeconds )
 861 {
 862   bool actorRemoved = RemoveActor( itemId );
 863   if( actorRemoved )
 864   {
 865     ReapplyAllConstraints( durationSeconds );
 866   }
 867 }
 868
 869 void ItemView::RemoveItems( const ItemIdContainer& itemIds, float durationSeconds )
 870 {
 871   bool actorRemoved( false );
 872
 873   // Remove from highest id to lowest
 874   set<ItemId> sortedItems;
 875   for( ConstItemIdIter iter = itemIds.begin(); itemIds.end() != iter; ++iter )
 876   {
 877     sortedItems.insert( *iter );
 878   }
 879
 880   for( set<ItemId>::reverse_iterator iter = sortedItems.rbegin(); sortedItems.rend() != iter; ++iter )
 881   {
 882     if( RemoveActor( *iter ) )
 883     {
 884       actorRemoved = true;
 885     }
 886   }
 887
 888   if( actorRemoved )
 889   {
 890     ReapplyAllConstraints( durationSeconds );
 891   }
 892 }
 893
 894 bool ItemView::RemoveActor(unsigned int itemId)
 895 {
 896   bool removed( false );
 897
 898   const ItemPoolIter removeIter = mItemPool.find( itemId );
 899
 900   if( removeIter != mItemPool.end() )
 901   {
 902     ReleaseActor(itemId, removeIter->second);
 903
 904     removed = true;
 905
 906     // Adjust the remaining item IDs, for example if item 2 is removed:
 907     //   Initial actors:     After insert:
 908     //     ID 1 - ActorA       ID 1 - ActorA
 909     //     ID 2 - ActorB       ID 2 - ActorC (previously ID 3)
 910     //     ID 3 - ActorC       ID 3 - ActorB (previously ID 4)
 911     //     ID 4 - ActorD
 912     for (ItemPoolIter iter = removeIter; iter != mItemPool.end(); ++iter)
 913     {
 914       if( iter->first < mItemPool.rbegin()->first )
 915       {
 916         iter->second = mItemPool[ iter->first + 1 ];
 917       }
 918       else
 919       {
 920         mItemPool.erase( iter );
 921         break;
 922       }
 923     }
 924   }
 925
 926   return removed;
 927 }
 928
 929 void ItemView::ReplaceItem( Item replacementItem, float durationSeconds )
 930 {
 931   mAddingItems = true;
 932
 933   SetupActor( replacementItem, durationSeconds );
 934   Self().Add( replacementItem.second );
 935
 936   const ItemPoolIter iter = mItemPool.find( replacementItem.first );
 937   if( mItemPool.end() != iter )
 938   {
 939     ReleaseActor(iter->first, iter->second);
 940     iter->second = replacementItem.second;
 941   }
 942   else
 943   {
 944     mItemPool.insert( replacementItem );
 945   }
 946
 947   CalculateDomainSize(Self().GetCurrentSize());
 948
 949   mAddingItems = false;
 950 }
 951
 952 void ItemView::ReplaceItems( const ItemContainer& replacementItems, float durationSeconds )
 953 {
 954   for( ConstItemIter iter = replacementItems.begin(); replacementItems.end() != iter; ++iter )
 955   {
 956     ReplaceItem( *iter, durationSeconds );
 957   }
 958 }
 959
 960 void ItemView::RemoveActorsOutsideRange( ItemRange range )
 961 {
 962   // Remove unwanted actors from the ItemView & ItemPool
 963   for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); )
 964   {
 965     unsigned int current = iter->first;
 966
 967     if( ! range.Within( current ) )
 968     {
 969       ReleaseActor(iter->first, iter->second);
 970
 971       mItemPool.erase( iter++ ); // erase invalidates the return value of post-increment; iter remains valid
 972     }
 973     else
 974     {
 975       ++iter;
 976     }
 977   }
 978 }
 979
 980 void ItemView::AddActorsWithinRange( ItemRange range, float durationSeconds )
 981 {
 982   range.end = min(mItemFactory.GetNumberOfItems(), range.end);
 983
 984   // The order of addition depends on the scroll direction.
 985   if (mRefreshOrderHint)
 986   {
 987     for (unsigned int itemId = range.begin; itemId < range.end; ++itemId)
 988     {
 989       AddNewActor( itemId, durationSeconds );
 990     }
 991   }
 992   else
 993   {
 994     for (unsigned int itemId = range.end; itemId > range.begin; --itemId)
 995     {
 996       AddNewActor( itemId-1, durationSeconds );
 997     }
 998   }
 999
1000   // Total number of items may change dynamically.
1001   // Always recalculate the domain size to reflect that.
1002   CalculateDomainSize(Self().GetCurrentSize());
1003 }
1004
1005 void ItemView::AddNewActor( unsigned int itemId, float durationSeconds )
1006 {
1007   mAddingItems = true;
1008
1009   if( mItemPool.end() == mItemPool.find( itemId ) )
1010   {
1011     Actor actor = mItemFactory.NewItem( itemId );
1012
1013     if( actor )
1014     {
1015       Item newItem( itemId, actor );
1016
1017       mItemPool.insert( newItem );
1018
1019       SetupActor( newItem, durationSeconds );
1020       Self().Add( actor );
1021     }
1022   }
1023
1024   mAddingItems = false;
1025 }
1026
1027 void ItemView::SetupActor( Item item, float durationSeconds )
1028 {
1029   item.second.SetParentOrigin( mItemsParentOrigin );
1030   item.second.SetAnchorPoint( mItemsAnchorPoint );
1031
1032   if( mActiveLayout )
1033   {
1034     Vector3 size;
1035     if( mActiveLayout->GetItemSize( item.first, mActiveLayoutTargetSize, size ) )
1036     {
1037       item.second.SetSize( size );
1038     }
1039
1040     ApplyConstraints( item.second, *mActiveLayout, item.first, durationSeconds );
1041   }
1042 }
1043
1044 void ItemView::ReleaseActor( ItemId item, Actor actor )
1045 {
1046   Self().Remove( actor );
1047   mItemFactory.ItemReleased(item, actor);
1048 }
1049
1050 ItemRange ItemView::GetItemRange(ItemLayout& layout, const Vector3& layoutSize, float layoutPosition, bool reserveExtra)
1051 {
1052   unsigned int itemCount = mItemFactory.GetNumberOfItems();
1053
1054   ItemRange available(0u, itemCount);
1055
1056   ItemRange range = layout.GetItemsWithinArea( layoutPosition, layoutSize );
1057
1058   if (reserveExtra)
1059   {
1060     // Add the reserve items for scrolling
1061     unsigned int extra = layout.GetReserveItemCount(layoutSize);
1062     range.begin = (range.begin >= extra) ? (range.begin - extra) : 0u;
1063     range.end += extra;
1064   }
1065
1066   return range.Intersection(available);
1067 }
1068
1069 void ItemView::OnChildAdd(Actor& child)
1070 {
1071   if(!mAddingItems)
1072   {
1073     // We don't want to do this downcast check for any item added by ItemView itself.
1074     Dali::Toolkit::ScrollComponent scrollComponent = Dali::Toolkit::ScrollComponent::DownCast(child);
1075     if(scrollComponent)
1076     {
1077       // Set the scroll connector when scroll bar is being added
1078       scrollComponent.SetScrollConnector(mScrollConnector);
1079     }
1080   }
1081 }
1082
1083 bool ItemView::OnTouchEvent(const TouchEvent& event)
1084 {
1085   // Ignore events with multiple-touch points
1086   if (event.GetPointCount() != 1)
1087   {
1088     return false;
1089   }
1090
1091   if (event.GetPoint(0).state == TouchPoint::Down)
1092   {
1093     // Cancel ongoing scrolling etc.
1094     mGestureState = Gesture::Clear;
1095
1096     mScrollDistance = 0.0f;
1097     mScrollSpeed = 0.0f;
1098     Self().SetProperty(mPropertyScrollSpeed, mScrollSpeed);
1099
1100     mScrollOvershoot = 0.0f;
1101     AnimateScrollOvershoot(0.0f);
1102
1103     mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1104
1105     RemoveAnimation(mScrollAnimation);
1106   }
1107
1108   return true; // consume since we're potentially scrolling
1109 }
1110
1111 bool ItemView::OnMouseWheelEvent(const MouseWheelEvent& event)
1112 {
1113   // Respond the mouse wheel event to scroll
1114   if (mActiveLayout)
1115   {
1116     Actor self = Self();
1117     const Vector3 layoutSize = Self().GetCurrentSize();
1118     float layoutPositionDelta = GetCurrentLayoutPosition(0) - (event.z * mMouseWheelScrollDistanceStep * mActiveLayout->GetScrollSpeedFactor());
1119     float firstItemScrollPosition = ClampFirstItemPosition(layoutPositionDelta, layoutSize, *mActiveLayout);
1120
1121     mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1122     self.SetProperty(mPropertyPosition, GetScrollPosition(firstItemScrollPosition, layoutSize));
1123     mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1124   }
1125
1126   if (mMouseWheelEventFinishedTimer.IsRunning())
1127   {
1128     mMouseWheelEventFinishedTimer.Stop();
1129   }
1130
1131   mMouseWheelEventFinishedTimer.Start();
1132
1133   return true;
1134 }
1135
1136 bool ItemView::OnMouseWheelEventFinished()
1137 {
1138   if (mActiveLayout)
1139   {
1140     RemoveAnimation(mScrollAnimation);
1141
1142     // No more mouse wheel events coming. Do the anchoring if enabled.
1143     mScrollAnimation = DoAnchoring();
1144     if (mScrollAnimation)
1145     {
1146       mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1147       mScrollAnimation.Play();
1148     }
1149     else
1150     {
1151       mScrollOvershoot = 0.0f;
1152       AnimateScrollOvershoot(0.0f);
1153
1154       mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1155     }
1156   }
1157
1158   return false;
1159 }
1160
1161 void ItemView::ApplyConstraints(Actor& actor, ItemLayout& layout, unsigned int itemId, float duration)
1162 {
1163   ItemLayout::Vector3Function positionConstraint;
1164   if (layout.GetPositionConstraint(itemId, positionConstraint))
1165   {
1166     WrappedVector3Constraint wrapped(positionConstraint, itemId);
1167
1168     Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
1169                                                       Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1170                                                       ParentSource( mPropertyScrollSpeed ),
1171                                                       ParentSource( Actor::SIZE ),
1172                                                       wrapped );
1173     constraint.SetApplyTime(duration);
1174     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1175
1176     actor.ApplyConstraint(constraint);
1177   }
1178
1179   ItemLayout::QuaternionFunction rotationConstraint;
1180   if (layout.GetRotationConstraint(itemId, rotationConstraint))
1181   {
1182     WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
1183
1184     Constraint constraint = Constraint::New<Quaternion>( Actor::ROTATION,
1185                                                          Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1186                                                          ParentSource( mPropertyScrollSpeed ),
1187                                                          ParentSource( Actor::SIZE ),
1188                                                          wrapped );
1189     constraint.SetApplyTime(duration);
1190     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1191
1192     actor.ApplyConstraint(constraint);
1193   }
1194
1195   ItemLayout::Vector3Function scaleConstraint;
1196   if (layout.GetScaleConstraint(itemId, scaleConstraint))
1197   {
1198     WrappedVector3Constraint wrapped(scaleConstraint, itemId);
1199
1200     Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
1201                                                       Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1202                                                       ParentSource( mPropertyScrollSpeed ),
1203                                                       ParentSource( Actor::SIZE ),
1204                                                       wrapped );
1205     constraint.SetApplyTime(duration);
1206     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1207
1208     actor.ApplyConstraint(constraint);
1209   }
1210
1211   ItemLayout::Vector4Function colorConstraint;
1212   if (layout.GetColorConstraint(itemId, colorConstraint))
1213   {
1214     WrappedVector4Constraint wrapped(colorConstraint, itemId);
1215
1216     Constraint constraint = Constraint::New<Vector4>( Actor::COLOR,
1217                                                       Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1218                                                       ParentSource( mPropertyScrollSpeed ),
1219                                                       ParentSource( Actor::SIZE ),
1220                                                       wrapped );
1221     constraint.SetApplyTime(duration);
1222     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1223
1224     // Release color constraints slowly; this allows ItemView to co-exist with ImageActor fade-in
1225     constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
1226     constraint.SetRemoveAction(Dali::Constraint::Discard);
1227
1228     actor.ApplyConstraint(constraint);
1229   }
1230
1231   ItemLayout::BoolFunction visibilityConstraint;
1232   if (layout.GetVisibilityConstraint(itemId, visibilityConstraint))
1233   {
1234     WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
1235
1236     Constraint constraint = Constraint::New<bool>( Actor::VISIBLE,
1237                                                    Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1238                                                    ParentSource( mPropertyScrollSpeed ),
1239                                                    ParentSource( Actor::SIZE ),
1240                                                    wrapped );
1241     constraint.SetApplyTime(duration);
1242     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1243
1244     // Release visibility constraints the same time as the color constraint
1245     constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
1246     constraint.SetRemoveAction(Dali::Constraint::Discard);
1247
1248     actor.ApplyConstraint(constraint);
1249   }
1250 }
1251
1252 void ItemView::ReapplyAllConstraints( float durationSeconds )
1253 {
1254   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
1255   {
1256     unsigned int id = iter->first;
1257     Actor actor = iter->second;
1258
1259     actor.RemoveConstraints();
1260     ApplyConstraints(actor, *mActiveLayout, id, durationSeconds);
1261   }
1262
1263   CalculateDomainSize(Self().GetCurrentSize());
1264 }
1265
1266 float ItemView::ClampFirstItemPosition(float targetPosition, const Vector3& targetSize, ItemLayout& layout)
1267 {
1268   Actor self = Self();
1269   float minLayoutPosition = layout.GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), targetSize);
1270   float clamppedPosition = min(0.0f, max(minLayoutPosition, targetPosition));
1271   mScrollOvershoot = targetPosition - clamppedPosition;
1272   self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);
1273
1274   return clamppedPosition;
1275 }
1276
1277 void ItemView::OnPan(PanGesture gesture)
1278 {
1279   Actor self = Self();
1280   const Vector3 layoutSize = Self().GetCurrentSize();
1281
1282   RemoveAnimation(mScrollAnimation);
1283
1284   // Short-circuit if there is no active layout
1285   if (!mActiveLayout)
1286   {
1287     mGestureState = Gesture::Clear;
1288     return;
1289   }
1290
1291   mGestureState = gesture.state;
1292
1293   switch (mGestureState)
1294   {
1295     case Gesture::Finished:
1296     {
1297       // Swipe Detection
1298       if (fabsf(mScrollDistance) > mMinimumSwipeDistance &&
1299           mScrollSpeed > mMinimumSwipeSpeed)
1300       {
1301         float direction = (mScrollDistance < 0.0f) ? -1.0f : 1.0f;
1302
1303         mRefreshOrderHint = true;
1304
1305         float currentLayoutPosition = GetCurrentLayoutPosition(0);
1306         float firstItemScrollPosition = ClampFirstItemPosition(currentLayoutPosition + mScrollSpeed * direction,
1307                                                                layoutSize,
1308                                                                *mActiveLayout);
1309
1310         if (mAnchoringEnabled)
1311         {
1312           firstItemScrollPosition = mActiveLayout->GetClosestAnchorPosition(firstItemScrollPosition);
1313         }
1314
1315         RemoveAnimation(mScrollAnimation);
1316
1317         float flickAnimationDuration = mActiveLayout->GetItemFlickAnimationDuration() * max(1.0f, fabsf(firstItemScrollPosition - GetCurrentLayoutPosition(0)));
1318         mScrollAnimation = Animation::New(flickAnimationDuration);
1319         mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
1320         mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, layoutSize), AlphaFunctions::EaseOut );
1321         mScrollAnimation.AnimateTo( Property(self, mPropertyScrollSpeed), 0.0f, AlphaFunctions::EaseOut );
1322
1323         mIsFlicking = true;
1324         // Check whether it has already scrolled to the end
1325         if(fabs(currentLayoutPosition - firstItemScrollPosition) > Math::MACHINE_EPSILON_0)
1326         {
1327           AnimateScrollOvershoot(0.0f);
1328         }
1329       }
1330
1331       // Anchoring may be triggered when there was no swipe
1332       if (!mScrollAnimation)
1333       {
1334         mScrollAnimation = DoAnchoring();
1335       }
1336
1337       // Reset the overshoot if no scroll animation.
1338       if (!mScrollAnimation)
1339       {
1340         mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1341
1342         AnimateScrollOvershoot(0.0f, false);
1343       }
1344     }
1345     break;
1346
1347     case Gesture::Started: // Fall through
1348     {
1349       mTotalPanDisplacement = Vector2::ZERO;
1350     }
1351
1352     case Gesture::Continuing:
1353     {
1354       mScrollDistance = CalculateScrollDistance(gesture.displacement, *mActiveLayout);
1355       mScrollSpeed = Clamp((gesture.GetSpeed() * mActiveLayout->GetFlickSpeedFactor() * MILLISECONDS_PER_SECONDS), 0.0f, mActiveLayout->GetMaximumSwipeSpeed());
1356
1357       // Refresh order depends on the direction of the scroll; negative is towards the last item.
1358       mRefreshOrderHint = mScrollDistance < 0.0f;
1359
1360       float layoutPositionDelta = GetCurrentLayoutPosition(0) + (mScrollDistance * mActiveLayout->GetScrollSpeedFactor());
1361
1362       float firstItemScrollPosition = ClampFirstItemPosition(layoutPositionDelta, layoutSize, *mActiveLayout);
1363
1364       mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1365       self.SetProperty(mPropertyPosition, GetScrollPosition(firstItemScrollPosition, layoutSize));
1366       mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1367
1368       mTotalPanDisplacement += gesture.displacement;
1369       mScrollOvershoot = layoutPositionDelta - firstItemScrollPosition;
1370       if( mScrollOvershoot > Math::MACHINE_EPSILON_1 )
1371       {
1372         AnimateScrollOvershoot(1.0f);
1373       }
1374       else if( mScrollOvershoot < -Math::MACHINE_EPSILON_1 )
1375       {
1376         AnimateScrollOvershoot(-1.0f);
1377       }
1378       else
1379       {
1380         AnimateScrollOvershoot(0.0f);
1381       }
1382     }
1383     break;
1384
1385     case Gesture::Cancelled:
1386     {
1387       mScrollAnimation = DoAnchoring();
1388     }
1389     break;
1390
1391     default:
1392       break;
1393   }
1394
1395   if (mScrollAnimation)
1396   {
1397     mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1398     mScrollAnimation.Play();
1399   }
1400 }
1401
1402 bool ItemView::OnAccessibilityPan(PanGesture gesture)
1403 {
1404   OnPan(gesture);
1405   return true;
1406 }
1407
1408 Actor ItemView::GetNextKeyboardFocusableActor(Actor actor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
1409 {
1410   Actor nextFocusActor;
1411   if(mActiveLayout)
1412   {
1413     int nextItemID = 0;
1414     if(!actor || actor == this->Self())
1415     {
1416       nextFocusActor = GetItem(nextItemID);
1417     }
1418     else if(actor && actor.GetParent() == this->Self())
1419     {
1420       int itemID = GetItemId(actor);
1421       nextItemID = mActiveLayout->GetNextFocusItemID(itemID, mItemFactory.GetNumberOfItems(), direction, loopEnabled);
1422       nextFocusActor = GetItem(nextItemID);
1423       if(nextFocusActor == actor)
1424       {
1425         // need to pass NULL actor back to focus manager
1426         nextFocusActor.Reset();
1427         return nextFocusActor;
1428       }
1429     }
1430     float layoutPosition = mActiveLayout->GetClosestAnchorPosition( GetCurrentLayoutPosition(0) );
1431     Vector3 layoutSize = Self().GetCurrentSize();
1432     if(!nextFocusActor)
1433     {
1434       // likely the current item is not buffered, so not in our item pool, probably best to get first viewable item
1435       ItemRange viewableItems = mActiveLayout->GetItemsWithinArea(layoutPosition, layoutSize);
1436       nextItemID = viewableItems.begin;
1437       nextFocusActor = GetItem(nextItemID);
1438     }
1439   }
1440   return nextFocusActor;
1441 }
1442
1443 void ItemView::OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor)
1444 {
1445   // only in this function if our chosen focus actor was actually used
1446   if(commitedFocusableActor)
1447   {
1448     int nextItemID = GetItemId(commitedFocusableActor);
1449     float layoutPosition = GetCurrentLayoutPosition(0);
1450     Vector3 layoutSize = Self().GetCurrentSize();
1451     Vector3 focusItemPosition = Vector3::ZERO;
1452     ItemLayout::Vector3Function itemPositionConstraint;
1453     if (mActiveLayout->GetPositionConstraint(nextItemID, itemPositionConstraint))
1454     {
1455       focusItemPosition = itemPositionConstraint(Vector3::ZERO, layoutPosition + nextItemID, 0.0f, layoutSize);
1456     }
1457
1458     float scrollTo = mActiveLayout->GetClosestOnScreenLayoutPosition(nextItemID, layoutPosition, layoutSize);
1459     ScrollTo(Vector3(0.0f, scrollTo, 0.0f), DEFAULT_KEYBOARD_FOCUS_SCROLL_DURATION);
1460   }
1461 }
1462
1463 Animation ItemView::DoAnchoring()
1464 {
1465   Animation anchoringAnimation;
1466   Actor self = Self();
1467
1468   if (mActiveLayout && mAnchoringEnabled)
1469   {
1470     float anchorPosition = mActiveLayout->GetClosestAnchorPosition( GetCurrentLayoutPosition(0) );
1471
1472     anchoringAnimation = Animation::New(mAnchoringDuration);
1473     anchoringAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), anchorPosition, AlphaFunctions::EaseOut );
1474     anchoringAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(anchorPosition, self.GetCurrentSize()), AlphaFunctions::EaseOut );
1475     anchoringAnimation.AnimateTo( Property(self, mPropertyScrollSpeed), 0.0f, AlphaFunctions::EaseOut );
1476     if(!mIsFlicking)
1477     {
1478       AnimateScrollOvershoot(0.0f);
1479     }
1480   }
1481
1482   return anchoringAnimation;
1483 }
1484
1485 void ItemView::OnScrollFinished(Animation& source)
1486 {
1487   Actor self = Self();
1488
1489   RemoveAnimation(mScrollAnimation); // mScrollAnimation is used to query whether we're scrolling
1490
1491   mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1492
1493   if(mIsFlicking && fabsf(mScrollOvershoot) > Math::MACHINE_EPSILON_1)
1494   {
1495     AnimateScrollOvershoot( mScrollOvershoot > 0.0f ? 1.0f : -1.0f, true);
1496   }
1497   else
1498   {
1499     // Reset the overshoot
1500     AnimateScrollOvershoot( 0.0f );
1501   }
1502   mIsFlicking = false;
1503
1504   mScrollOvershoot = 0.0f;
1505 }
1506
1507 void ItemView::OnOvershootOnFinished(Animation& animation)
1508 {
1509   mAnimatingOvershootOn = false;
1510   mScrollOvershootAnimation.FinishedSignal().Disconnect(this, &ItemView::OnOvershootOnFinished);
1511   RemoveAnimation(mScrollOvershootAnimation);
1512   if(mAnimateOvershootOff)
1513   {
1514     AnimateScrollOvershoot(0.0f);
1515   }
1516 }
1517
1518 void ItemView::ScrollToItem(unsigned int itemId, float durationSeconds)
1519 {
1520   Actor self = Self();
1521   const Vector3 layoutSize = Self().GetCurrentSize();
1522   float firstItemScrollPosition = ClampFirstItemPosition(mActiveLayout->GetItemScrollToPosition(itemId), layoutSize, *mActiveLayout);
1523
1524   if(durationSeconds > 0.0f)
1525   {
1526     RemoveAnimation(mScrollAnimation);
1527     mScrollAnimation = Animation::New(durationSeconds);
1528     mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
1529     mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, layoutSize), AlphaFunctions::EaseOut );
1530     mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1531     mScrollAnimation.Play();
1532   }
1533   else
1534   {
1535     mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1536     AnimateScrollOvershoot(0.0f);
1537   }
1538
1539   mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1540 }
1541
1542 void ItemView::RemoveAnimation(Animation& animation)
1543 {
1544   if(animation)
1545   {
1546     // Cease animating, and reset handle.
1547     animation.Clear();
1548     animation.Reset();
1549   }
1550 }
1551
1552 void ItemView::CalculateDomainSize(const Vector3& layoutSize)
1553 {
1554   Actor self = Self();
1555
1556   Vector3 firstItemPosition(Vector3::ZERO);
1557   Vector3 lastItemPosition(Vector3::ZERO);
1558
1559   if(mActiveLayout)
1560   {
1561     ItemLayout::Vector3Function firstItemPositionConstraint;
1562     if (mActiveLayout->GetPositionConstraint(0, firstItemPositionConstraint))
1563     {
1564       firstItemPosition = firstItemPositionConstraint(Vector3::ZERO, 0, 0.0f, layoutSize);
1565     }
1566
1567     float minLayoutPosition = mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), layoutSize);
1568     self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);
1569
1570     ItemLayout::Vector3Function lastItemPositionConstraint;
1571     if (mActiveLayout->GetPositionConstraint(fabs(minLayoutPosition), lastItemPositionConstraint))
1572     {
1573       lastItemPosition = lastItemPositionConstraint(Vector3::ZERO, fabs(minLayoutPosition), 0.0f, layoutSize);
1574     }
1575
1576     float domainSize;
1577
1578     if(IsHorizontal(mActiveLayout->GetOrientation()))
1579     {
1580       self.SetProperty(mPropertyPositionMin, Vector3(0.0f, firstItemPosition.x, 0.0f));
1581       self.SetProperty(mPropertyPositionMax, Vector3(0.0f, lastItemPosition.x, 0.0f));
1582       domainSize = fabs(firstItemPosition.x - lastItemPosition.x);
1583     }
1584     else
1585     {
1586       self.SetProperty(mPropertyPositionMin, Vector3(0.0f, firstItemPosition.y, 0.0f));
1587       self.SetProperty(mPropertyPositionMax, Vector3(0.0f, lastItemPosition.y, 0.0f));
1588       domainSize = fabs(firstItemPosition.y - lastItemPosition.y);
1589     }
1590
1591     mScrollConnector.SetScrollDomain(minLayoutPosition, 0.0f, domainSize);
1592
1593     bool isLayoutScrollable = IsLayoutScrollable(layoutSize);
1594     self.SetProperty(mPropertyCanScrollVertical, isLayoutScrollable);
1595     self.SetProperty(mPropertyCanScrollHorizontal, false);
1596   }
1597 }
1598
1599 Vector3 ItemView::GetDomainSize() const
1600 {
1601   Actor self = Self();
1602
1603   float minScrollPosition = self.GetProperty<float>(mPropertyPositionMin);
1604   float maxScrollPosition = self.GetProperty<float>(mPropertyPositionMax);
1605
1606   return Vector3(0.0f, fabs(maxScrollPosition - minScrollPosition), 0.0f);
1607 }
1608
1609 bool ItemView::IsLayoutScrollable(const Vector3& layoutSize)
1610 {
1611   Actor self = Self();
1612
1613   float currentLayoutPosition = ClampFirstItemPosition( GetCurrentLayoutPosition(0), layoutSize, *mActiveLayout );
1614   float forwardClampedPosition = ClampFirstItemPosition(currentLayoutPosition + 1.0, layoutSize, *mActiveLayout);
1615   float backwardClampedPosition = ClampFirstItemPosition(currentLayoutPosition - 1.0, layoutSize, *mActiveLayout);
1616
1617   return (fabs(forwardClampedPosition - backwardClampedPosition) > Math::MACHINE_EPSILON_0);
1618 }
1619
1620 float ItemView::GetScrollPosition(float layoutPosition, const Vector3& layoutSize) const
1621 {
1622   Vector3 firstItemPosition(Vector3::ZERO);
1623   ItemLayout::Vector3Function firstItemPositionConstraint;
1624   if (mActiveLayout->GetPositionConstraint(0, firstItemPositionConstraint))
1625   {
1626     firstItemPosition = firstItemPositionConstraint(Vector3::ZERO, layoutPosition, 0.0f, layoutSize);
1627   }
1628
1629   return IsHorizontal(mActiveLayout->GetOrientation()) ? firstItemPosition.x: firstItemPosition.y;
1630 }
1631
1632 Vector3 ItemView::GetCurrentScrollPosition() const
1633 {
1634   float currentLayoutPosition = GetCurrentLayoutPosition(0);
1635   return Vector3(0.0f, GetScrollPosition(currentLayoutPosition, Self().GetCurrentSize()), 0.0f);
1636 }
1637
1638 void ItemView::AddOverlay(Actor actor)
1639 {
1640   Self().Add(actor);
1641 }
1642
1643 void ItemView::RemoveOverlay(Actor actor)
1644 {
1645   Self().Remove(actor);
1646 }
1647
1648 void ItemView::ScrollTo(const Vector3& position, float duration)
1649 {
1650   Actor self = Self();
1651   const Vector3 layoutSize = Self().GetCurrentSize();
1652
1653   float firstItemScrollPosition = ClampFirstItemPosition(position.y, layoutSize, *mActiveLayout);
1654
1655   if(duration > 0.0f)
1656   {
1657     RemoveAnimation(mScrollAnimation);
1658     mScrollAnimation = Animation::New(duration);
1659     mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
1660     mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, layoutSize), AlphaFunctions::EaseOut );
1661     mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1662     mScrollAnimation.Play();
1663   }
1664   else
1665   {
1666     mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1667     AnimateScrollOvershoot(0.0f);
1668   }
1669
1670   mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1671 }
1672
1673 void ItemView::SetOvershootEffectColor( const Vector4& color )
1674 {
1675   mOvershootEffectColor = color;
1676   if( mOvershootOverlay )
1677   {
1678     mOvershootOverlay.SetColor( color );
1679   }
1680 }
1681
1682 void ItemView::SetOvershootEnabled( bool enable )
1683 {
1684   Actor self = Self();
1685   if( enable )
1686   {
1687     Property::Index effectOvershootPropertyIndex = Property::INVALID_INDEX;
1688     mOvershootOverlay = CreateBouncingEffectActor( effectOvershootPropertyIndex );
1689     mOvershootOverlay.SetColor(mOvershootEffectColor);
1690     mOvershootOverlay.SetParentOrigin(ParentOrigin::TOP_LEFT);
1691     mOvershootOverlay.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1692     mOvershootOverlay.SetDrawMode(DrawMode::OVERLAY);
1693     self.Add(mOvershootOverlay);
1694
1695     Constraint constraint = Constraint::New<Vector3>( Actor::SIZE,
1696                                                       ParentSource( mPropertyScrollDirection ),
1697                                                       Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1698                                                       ParentSource( Actor::SIZE ),
1699                                                       OvershootOverlaySizeConstraint() );
1700     mOvershootOverlay.ApplyConstraint(constraint);
1701     mOvershootOverlay.SetSize(OVERSHOOT_BOUNCE_ACTOR_DEFAULT_SIZE.width, OVERSHOOT_BOUNCE_ACTOR_DEFAULT_SIZE.height);
1702
1703     constraint = Constraint::New<Quaternion>( Actor::ROTATION,
1704                                               ParentSource( mPropertyScrollDirection ),
1705                                               Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1706                                               OvershootOverlayRotationConstraint() );
1707     mOvershootOverlay.ApplyConstraint(constraint);
1708
1709     constraint = Constraint::New<Vector3>( Actor::POSITION,
1710                                            ParentSource( Actor::SIZE ),
1711                                            ParentSource( mPropertyScrollDirection ),
1712                                            Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1713                                            OvershootOverlayPositionConstraint() );
1714     mOvershootOverlay.ApplyConstraint(constraint);
1715
1716     constraint = Constraint::New<bool>( Actor::VISIBLE,
1717                                         ParentSource( mPropertyCanScrollVertical ),
1718                                         OvershootOverlayVisibilityConstraint() );
1719     mOvershootOverlay.ApplyConstraint(constraint);
1720
1721     Actor self = Self();
1722     constraint = Constraint::New<float>( effectOvershootPropertyIndex,
1723                                          Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1724                                          EqualToConstraint() );
1725     mOvershootOverlay.ApplyConstraint(constraint);
1726   }
1727   else
1728   {
1729     if( mOvershootOverlay )
1730     {
1731       self.Remove(mOvershootOverlay);
1732       mOvershootOverlay.Reset();
1733     }
1734   }
1735 }
1736
1737 float ItemView::CalculateScrollOvershoot()
1738 {
1739   float overshoot = 0.0f;
1740
1741   if(mActiveLayout)
1742   {
1743     // The overshoot must be calculated from the accumulated pan gesture displacement
1744     // since the pan gesture starts.
1745     Actor self = Self();
1746     float scrollDistance = CalculateScrollDistance(mTotalPanDisplacement, *mActiveLayout) * mActiveLayout->GetScrollSpeedFactor();
1747     float positionDelta = GetCurrentLayoutPosition(0) + scrollDistance;
1748     float minLayoutPosition = mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), Self().GetCurrentSize());
1749     self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);
1750     float clamppedPosition = min(0.0f, max(minLayoutPosition, positionDelta));
1751     overshoot = positionDelta - clamppedPosition;
1752   }
1753
1754   return overshoot;
1755 }
1756
1757 void ItemView::AnimateScrollOvershoot(float overshootAmount, bool animateBack)
1758 {
1759   bool animatingOn = fabsf(overshootAmount) > Math::MACHINE_EPSILON_1;
1760
1761   // make sure we animate back if needed
1762   mAnimateOvershootOff = animateBack || (!animatingOn && mAnimatingOvershootOn);
1763
1764   if( mAnimatingOvershootOn )
1765   {
1766     // animating on, do not allow animate off
1767     return;
1768   }
1769
1770   Actor self = Self();
1771   float currentOvershoot = mScrollPositionObject.GetProperty<float>(ScrollConnector::OVERSHOOT);
1772   float duration = DEFAULT_OVERSHOOT_ANIMATION_DURATION * (animatingOn ? (1.0f - fabsf(currentOvershoot)) : fabsf(currentOvershoot));
1773
1774   RemoveAnimation(mScrollOvershootAnimation);
1775   mScrollOvershootAnimation = Animation::New(duration);
1776   mScrollOvershootAnimation.FinishedSignal().Connect(this, &ItemView::OnOvershootOnFinished);
1777   mScrollOvershootAnimation.AnimateTo( Property(mScrollPositionObject, ScrollConnector::OVERSHOOT), overshootAmount, TimePeriod(0.0f, duration) );
1778   mScrollOvershootAnimation.Play();
1779
1780   mAnimatingOvershootOn = animatingOn;
1781 }
1782
1783 void ItemView::SetItemsParentOrigin( const Vector3& parentOrigin )
1784 {
1785   if( parentOrigin != mItemsParentOrigin )
1786   {
1787     mItemsParentOrigin = parentOrigin;
1788     for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
1789     {
1790       iter->second.SetParentOrigin(parentOrigin);
1791     }
1792   }
1793 }
1794
1795 Vector3 ItemView::GetItemsParentOrigin() const
1796 {
1797   return mItemsParentOrigin;
1798 }
1799
1800 void ItemView::SetItemsAnchorPoint( const Vector3& anchorPoint )
1801 {
1802   if( anchorPoint != mItemsAnchorPoint )
1803   {
1804     mItemsAnchorPoint = anchorPoint;
1805     for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
1806     {
1807       iter->second.SetAnchorPoint(anchorPoint);
1808     }
1809   }
1810 }
1811
1812 Vector3 ItemView::GetItemsAnchorPoint() const
1813 {
1814   return mItemsAnchorPoint;
1815 }
1816
1817 void ItemView::GetItemsRange(ItemRange& range)
1818 {
1819   range.begin = mItemPool.begin()->first;
1820   range.end = mItemPool.rbegin()->first + 1;
1821 }
1822
1823 } // namespace Internal
1824
1825 } // namespace Toolkit
1826
1827 } // namespace Dali