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(0.0f),
 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(DEFAULT_REFRESH_INTERVAL_LAYOUT_POSITIONS);
 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   mRefreshEnabled = false;
 513
 514   Actor self = Self();
 515
 516   // The ItemView size should match the active layout size
 517   self.SetSize(targetSize);
 518   mActiveLayoutTargetSize = targetSize;
 519
 520   // Switch to the new layout
 521   mActiveLayout = mLayouts[layoutIndex].Get();
 522
 523   // Move the items to the new layout positions...
 524
 525   bool resizeAnimationNeeded(false);
 526
 527   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
 528   {
 529     unsigned int itemId = iter->first;
 530     Actor actor = iter->second;
 531
 532     // Remove constraints from previous layout
 533     actor.RemoveConstraints();
 534
 535     Vector3 size;
 536     if(mActiveLayout->GetItemSize(itemId, targetSize, size))
 537     {
 538       if( durationSeconds > 0.0f )
 539       {
 540         // Use a size animation
 541         if (!resizeAnimationNeeded)
 542         {
 543           resizeAnimationNeeded = true;
 544           RemoveAnimation(mResizeAnimation);
 545           mResizeAnimation = Animation::New(durationSeconds);
 546         }
 547
 548         // The layout provides its own resize animation
 549         mActiveLayout->GetResizeAnimation(mResizeAnimation, actor, size, durationSeconds);
 550       }
 551       else
 552       {
 553         // resize immediately
 554         actor.SetSize(size);
 555       }
 556     }
 557
 558     ApplyConstraints(actor, *mActiveLayout, itemId, durationSeconds);
 559   }
 560
 561   if (resizeAnimationNeeded)
 562   {
 563     mResizeAnimation.Play();
 564   }
 565
 566   // Refresh the new layout
 567   ItemRange range = GetItemRange(*mActiveLayout, targetSize, GetCurrentLayoutPosition(0), false/* don't reserve extra*/);
 568   AddActorsWithinRange( range, durationSeconds );
 569
 570   // Scroll to an appropriate layout position
 571
 572   bool scrollAnimationNeeded(false);
 573   float firstItemScrollPosition(0.0f);
 574
 575   float current = GetCurrentLayoutPosition(0);
 576   float minimum = ClampFirstItemPosition(current, targetSize, *mActiveLayout);
 577   self.SetProperty(mPropertyPosition, GetScrollPosition(current, targetSize));
 578
 579   if (current < minimum)
 580   {
 581     scrollAnimationNeeded = true;
 582     firstItemScrollPosition = minimum;
 583   }
 584   else if (mAnchoringEnabled)
 585   {
 586     scrollAnimationNeeded = true;
 587     firstItemScrollPosition = mActiveLayout->GetClosestAnchorPosition(current);
 588   }
 589
 590   if (scrollAnimationNeeded)
 591   {
 592     RemoveAnimation(mScrollAnimation);
 593     mScrollAnimation = Animation::New(durationSeconds);
 594     mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
 595     mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, targetSize), AlphaFunctions::EaseOut );
 596     mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnLayoutActivationScrollFinished);
 597     mScrollAnimation.Play();
 598   }
 599
 600   self.SetProperty(mPropertyMinimumLayoutPosition, mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), targetSize));
 601   AnimateScrollOvershoot(0.0f);
 602   mScrollOvershoot = 0.0f;
 603
 604   Radian scrollDirection(mActiveLayout->GetScrollDirection());
 605   float orientation = static_cast<float>(mActiveLayout->GetOrientation());
 606   self.SetProperty(mPropertyScrollDirection, Vector3(sinf(scrollDirection), cosf(scrollDirection), orientation));
 607
 608   self.SetProperty(mPropertyScrollSpeed, mScrollSpeed);
 609
 610   CalculateDomainSize(targetSize);
 611 }
 612
 613 void ItemView::DeactivateCurrentLayout()
 614 {
 615   if (mActiveLayout)
 616   {
 617     for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
 618     {
 619       Actor actor = iter->second;
 620       actor.RemoveConstraints();
 621     }
 622
 623     mActiveLayout = NULL;
 624   }
 625 }
 626
 627 void ItemView::SetDefaultAlphaFunction(AlphaFunction func)
 628 {
 629   mDefaultAlphaFunction = func;
 630 }
 631
 632 AlphaFunction ItemView::GetDefaultAlphaFunction() const
 633 {
 634   return mDefaultAlphaFunction;
 635 }
 636
 637 void ItemView::OnRefreshNotification(PropertyNotification& source)
 638 {
 639   if(mRefreshEnabled)
 640   {
 641     // Only refresh the cache during normal scrolling
 642     DoRefresh(GetCurrentLayoutPosition(0), true);
 643   }
 644 }
 645
 646 void ItemView::DoRefresh(float currentLayoutPosition, bool cacheExtra)
 647 {
 648   if (mActiveLayout)
 649   {
 650     ItemRange range = GetItemRange(*mActiveLayout, mActiveLayoutTargetSize, currentLayoutPosition, cacheExtra/*reserve extra*/);
 651     RemoveActorsOutsideRange( range );
 652     AddActorsWithinRange( range, 0.0f/*immediate*/ );
 653
 654     mScrollUpdatedSignalV2.Emit( Vector3(0.0f, currentLayoutPosition, 0.0f) );
 655   }
 656 }
 657
 658 void ItemView::SetMinimumSwipeSpeed(float speed)
 659 {
 660   mMinimumSwipeSpeed = speed;
 661 }
 662
 663 float ItemView::GetMinimumSwipeSpeed() const
 664 {
 665   return mMinimumSwipeSpeed;
 666 }
 667
 668 void ItemView::SetMinimumSwipeDistance(float distance)
 669 {
 670   mMinimumSwipeDistance = distance;
 671 }
 672
 673 float ItemView::GetMinimumSwipeDistance() const
 674 {
 675   return mMinimumSwipeDistance;
 676 }
 677
 678 void ItemView::SetMouseWheelScrollDistanceStep(float step)
 679 {
 680   mMouseWheelScrollDistanceStep = step;
 681 }
 682
 683 float ItemView::GetMouseWheelScrollDistanceStep() const
 684 {
 685   return mMouseWheelScrollDistanceStep;
 686 }
 687
 688 void ItemView::SetAnchoring(bool enabled)
 689 {
 690   mAnchoringEnabled = enabled;
 691 }
 692
 693 bool ItemView::GetAnchoring() const
 694 {
 695   return mAnchoringEnabled;
 696 }
 697
 698 void ItemView::SetAnchoringDuration(float durationSeconds)
 699 {
 700   mAnchoringDuration = durationSeconds;
 701 }
 702
 703 float ItemView::GetAnchoringDuration() const
 704 {
 705   return mAnchoringDuration;
 706 }
 707
 708 void ItemView::SetRefreshInterval(float intervalLayoutPositions)
 709 {
 710   if(mRefreshIntervalLayoutPositions != intervalLayoutPositions)
 711   {
 712     mRefreshIntervalLayoutPositions = intervalLayoutPositions;
 713
 714     if(mRefreshNotification)
 715     {
 716       mScrollPositionObject.RemovePropertyNotification(mRefreshNotification);
 717     }
 718     mRefreshNotification = mScrollPositionObject.AddPropertyNotification( ScrollConnector::SCROLL_POSITION, StepCondition(mRefreshIntervalLayoutPositions, 0.0f) );
 719     mRefreshNotification.NotifySignal().Connect( this, &ItemView::OnRefreshNotification );
 720   }
 721 }
 722
 723 float ItemView::GetRefreshInterval() const
 724 {
 725   return mRefreshIntervalLayoutPositions;
 726 }
 727
 728 void ItemView::SetRefreshEnabled(bool enabled)
 729 {
 730   mRefreshEnabled = enabled;
 731 }
 732
 733 Actor ItemView::GetItem(unsigned int itemId) const
 734 {
 735   Actor actor;
 736
 737   ConstItemPoolIter iter = mItemPool.find( itemId );
 738   if( iter != mItemPool.end() )
 739   {
 740     actor = iter->second;
 741   }
 742
 743   return actor;
 744 }
 745
 746 unsigned int ItemView::GetItemId( Actor actor ) const
 747 {
 748   unsigned int itemId( 0 );
 749
 750   for ( ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter )
 751   {
 752     if( iter->second == actor )
 753     {
 754       itemId = iter->first;
 755       break;
 756     }
 757   }
 758
 759   return itemId;
 760 }
 761
 762 void ItemView::InsertItem( Item newItem, float durationSeconds )
 763 {
 764   mAddingItems = true;
 765
 766   SetupActor( newItem, durationSeconds );
 767   Self().Add( newItem.second );
 768
 769   ItemPoolIter foundIter = mItemPool.find( newItem.first );
 770   if( mItemPool.end() != foundIter )
 771   {
 772     Actor moveMe = foundIter->second;
 773     foundIter->second = newItem.second;
 774
 775     // Move the existing actors to make room
 776     for( ItemPoolIter iter = ++foundIter; mItemPool.end() != iter; ++iter )
 777     {
 778       Actor temp = iter->second;
 779       iter->second = moveMe;
 780       moveMe = temp;
 781
 782       iter->second.RemoveConstraints();
 783       ApplyConstraints( iter->second, *mActiveLayout, iter->first, durationSeconds );
 784     }
 785
 786     // Create last item
 787     ItemId lastId = mItemPool.rbegin()->first;
 788     Item lastItem( lastId + 1, moveMe );
 789     mItemPool.insert( lastItem );
 790
 791     lastItem.second.RemoveConstraints();
 792     ApplyConstraints( lastItem.second, *mActiveLayout, lastItem.first, durationSeconds );
 793   }
 794   else
 795   {
 796     mItemPool.insert( newItem );
 797   }
 798
 799   CalculateDomainSize(Self().GetCurrentSize());
 800
 801   mAddingItems = false;
 802 }
 803
 804 void ItemView::InsertItems( const ItemContainer& newItems, float durationSeconds )
 805 {
 806   mAddingItems = true;
 807
 808   // Insert from lowest id to highest
 809   set<Item> sortedItems;
 810   for( ConstItemIter iter = newItems.begin(); newItems.end() != iter; ++iter )
 811   {
 812     sortedItems.insert( *iter );
 813   }
 814
 815   for( set<Item>::iterator iter = sortedItems.begin(); sortedItems.end() != iter; ++iter )
 816   {
 817     Self().Add( iter->second );
 818
 819     cout << "inserting item: " << iter->first << endl;
 820
 821     ItemPoolIter foundIter = mItemPool.find( iter->first );
 822     if( mItemPool.end() != foundIter )
 823     {
 824       Actor moveMe = foundIter->second;
 825       foundIter->second = iter->second;
 826
 827       // Move the existing actors to make room
 828       for( ItemPoolIter iter = ++foundIter; mItemPool.end() != iter; ++iter )
 829       {
 830         Actor temp = iter->second;
 831         iter->second = moveMe;
 832         moveMe = temp;
 833       }
 834
 835       // Create last item
 836       ItemId lastId = mItemPool.rbegin()->first;
 837       Item lastItem( lastId + 1, moveMe );
 838       mItemPool.insert( lastItem );
 839     }
 840     else
 841     {
 842       mItemPool.insert( *iter );
 843     }
 844   }
 845
 846   // Relayout everything
 847   for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
 848   {
 849     // If newly inserted
 850     if( FindById( newItems, iter->first ) )
 851     {
 852       SetupActor( *iter, durationSeconds );
 853     }
 854     else
 855     {
 856       iter->second.RemoveConstraints();
 857       ApplyConstraints( iter->second, *mActiveLayout, iter->first, durationSeconds );
 858     }
 859   }
 860
 861   CalculateDomainSize(Self().GetCurrentSize());
 862
 863   mAddingItems = false;
 864 }
 865
 866 void ItemView::RemoveItem( unsigned int itemId, float durationSeconds )
 867 {
 868   bool actorRemoved = RemoveActor( itemId );
 869   if( actorRemoved )
 870   {
 871     ReapplyAllConstraints( durationSeconds );
 872   }
 873 }
 874
 875 void ItemView::RemoveItems( const ItemIdContainer& itemIds, float durationSeconds )
 876 {
 877   bool actorRemoved( false );
 878
 879   // Remove from highest id to lowest
 880   set<ItemId> sortedItems;
 881   for( ConstItemIdIter iter = itemIds.begin(); itemIds.end() != iter; ++iter )
 882   {
 883     sortedItems.insert( *iter );
 884   }
 885
 886   for( set<ItemId>::reverse_iterator iter = sortedItems.rbegin(); sortedItems.rend() != iter; ++iter )
 887   {
 888     if( RemoveActor( *iter ) )
 889     {
 890       actorRemoved = true;
 891     }
 892   }
 893
 894   if( actorRemoved )
 895   {
 896     ReapplyAllConstraints( durationSeconds );
 897   }
 898 }
 899
 900 bool ItemView::RemoveActor(unsigned int itemId)
 901 {
 902   bool removed( false );
 903
 904   const ItemPoolIter removeIter = mItemPool.find( itemId );
 905
 906   if( removeIter != mItemPool.end() )
 907   {
 908     ReleaseActor(itemId, removeIter->second);
 909
 910     removed = true;
 911
 912     // Adjust the remaining item IDs, for example if item 2 is removed:
 913     //   Initial actors:     After insert:
 914     //     ID 1 - ActorA       ID 1 - ActorA
 915     //     ID 2 - ActorB       ID 2 - ActorC (previously ID 3)
 916     //     ID 3 - ActorC       ID 3 - ActorB (previously ID 4)
 917     //     ID 4 - ActorD
 918     for (ItemPoolIter iter = removeIter; iter != mItemPool.end(); ++iter)
 919     {
 920       if( iter->first < mItemPool.rbegin()->first )
 921       {
 922         iter->second = mItemPool[ iter->first + 1 ];
 923       }
 924       else
 925       {
 926         mItemPool.erase( iter );
 927         break;
 928       }
 929     }
 930   }
 931
 932   return removed;
 933 }
 934
 935 void ItemView::ReplaceItem( Item replacementItem, float durationSeconds )
 936 {
 937   mAddingItems = true;
 938
 939   SetupActor( replacementItem, durationSeconds );
 940   Self().Add( replacementItem.second );
 941
 942   const ItemPoolIter iter = mItemPool.find( replacementItem.first );
 943   if( mItemPool.end() != iter )
 944   {
 945     ReleaseActor(iter->first, iter->second);
 946     iter->second = replacementItem.second;
 947   }
 948   else
 949   {
 950     mItemPool.insert( replacementItem );
 951   }
 952
 953   CalculateDomainSize(Self().GetCurrentSize());
 954
 955   mAddingItems = false;
 956 }
 957
 958 void ItemView::ReplaceItems( const ItemContainer& replacementItems, float durationSeconds )
 959 {
 960   for( ConstItemIter iter = replacementItems.begin(); replacementItems.end() != iter; ++iter )
 961   {
 962     ReplaceItem( *iter, durationSeconds );
 963   }
 964 }
 965
 966 void ItemView::RemoveActorsOutsideRange( ItemRange range )
 967 {
 968   // Remove unwanted actors from the ItemView & ItemPool
 969   for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); )
 970   {
 971     unsigned int current = iter->first;
 972
 973     if( ! range.Within( current ) )
 974     {
 975       ReleaseActor(iter->first, iter->second);
 976
 977       mItemPool.erase( iter++ ); // erase invalidates the return value of post-increment; iter remains valid
 978     }
 979     else
 980     {
 981       ++iter;
 982     }
 983   }
 984 }
 985
 986 void ItemView::AddActorsWithinRange( ItemRange range, float durationSeconds )
 987 {
 988   range.end = min(mItemFactory.GetNumberOfItems(), range.end);
 989
 990   // The order of addition depends on the scroll direction.
 991   if (mRefreshOrderHint)
 992   {
 993     for (unsigned int itemId = range.begin; itemId < range.end; ++itemId)
 994     {
 995       AddNewActor( itemId, durationSeconds );
 996     }
 997   }
 998   else
 999   {
1000     for (unsigned int itemId = range.end; itemId > range.begin; --itemId)
1001     {
1002       AddNewActor( itemId-1, durationSeconds );
1003     }
1004   }
1005
1006   // Total number of items may change dynamically.
1007   // Always recalculate the domain size to reflect that.
1008   CalculateDomainSize(Self().GetCurrentSize());
1009 }
1010
1011 void ItemView::AddNewActor( unsigned int itemId, float durationSeconds )
1012 {
1013   mAddingItems = true;
1014
1015   if( mItemPool.end() == mItemPool.find( itemId ) )
1016   {
1017     Actor actor = mItemFactory.NewItem( itemId );
1018
1019     if( actor )
1020     {
1021       Item newItem( itemId, actor );
1022
1023       mItemPool.insert( newItem );
1024
1025       SetupActor( newItem, durationSeconds );
1026       Self().Add( actor );
1027     }
1028   }
1029
1030   mAddingItems = false;
1031 }
1032
1033 void ItemView::SetupActor( Item item, float durationSeconds )
1034 {
1035   item.second.SetParentOrigin( mItemsParentOrigin );
1036   item.second.SetAnchorPoint( mItemsAnchorPoint );
1037
1038   if( mActiveLayout )
1039   {
1040     Vector3 size;
1041     if( mActiveLayout->GetItemSize( item.first, mActiveLayoutTargetSize, size ) )
1042     {
1043       item.second.SetSize( size );
1044     }
1045
1046     ApplyConstraints( item.second, *mActiveLayout, item.first, durationSeconds );
1047   }
1048 }
1049
1050 void ItemView::ReleaseActor( ItemId item, Actor actor )
1051 {
1052   Self().Remove( actor );
1053   mItemFactory.ItemReleased(item, actor);
1054 }
1055
1056 ItemRange ItemView::GetItemRange(ItemLayout& layout, const Vector3& layoutSize, float layoutPosition, bool reserveExtra)
1057 {
1058   unsigned int itemCount = mItemFactory.GetNumberOfItems();
1059
1060   ItemRange available(0u, itemCount);
1061
1062   ItemRange range = layout.GetItemsWithinArea( layoutPosition, layoutSize );
1063
1064   if (reserveExtra)
1065   {
1066     // Add the reserve items for scrolling
1067     unsigned int extra = layout.GetReserveItemCount(layoutSize);
1068     range.begin = (range.begin >= extra) ? (range.begin - extra) : 0u;
1069     range.end += extra;
1070   }
1071
1072   return range.Intersection(available);
1073 }
1074
1075 void ItemView::OnChildAdd(Actor& child)
1076 {
1077   if(!mAddingItems)
1078   {
1079     // We don't want to do this downcast check for any item added by ItemView itself.
1080     Dali::Toolkit::ScrollComponent scrollComponent = Dali::Toolkit::ScrollComponent::DownCast(child);
1081     if(scrollComponent)
1082     {
1083       // Set the scroll connector when scroll bar is being added
1084       scrollComponent.SetScrollConnector(mScrollConnector);
1085     }
1086   }
1087 }
1088
1089 bool ItemView::OnTouchEvent(const TouchEvent& event)
1090 {
1091   // Ignore events with multiple-touch points
1092   if (event.GetPointCount() != 1)
1093   {
1094     return false;
1095   }
1096
1097   if (event.GetPoint(0).state == TouchPoint::Down)
1098   {
1099     // Cancel ongoing scrolling etc.
1100     mGestureState = Gesture::Clear;
1101
1102     mScrollDistance = 0.0f;
1103     mScrollSpeed = 0.0f;
1104     Self().SetProperty(mPropertyScrollSpeed, mScrollSpeed);
1105
1106     mScrollOvershoot = 0.0f;
1107     AnimateScrollOvershoot(0.0f);
1108
1109     mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1110
1111     RemoveAnimation(mScrollAnimation);
1112   }
1113
1114   return true; // consume since we're potentially scrolling
1115 }
1116
1117 bool ItemView::OnMouseWheelEvent(const MouseWheelEvent& event)
1118 {
1119   // Respond the mouse wheel event to scroll
1120   if (mActiveLayout)
1121   {
1122     Actor self = Self();
1123     const Vector3 layoutSize = Self().GetCurrentSize();
1124     float layoutPositionDelta = GetCurrentLayoutPosition(0) - (event.z * mMouseWheelScrollDistanceStep * mActiveLayout->GetScrollSpeedFactor());
1125     float firstItemScrollPosition = ClampFirstItemPosition(layoutPositionDelta, layoutSize, *mActiveLayout);
1126
1127     mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1128     self.SetProperty(mPropertyPosition, GetScrollPosition(firstItemScrollPosition, layoutSize));
1129     mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1130     mRefreshEnabled = true;
1131   }
1132
1133   if (mMouseWheelEventFinishedTimer.IsRunning())
1134   {
1135     mMouseWheelEventFinishedTimer.Stop();
1136   }
1137
1138   mMouseWheelEventFinishedTimer.Start();
1139
1140   return true;
1141 }
1142
1143 bool ItemView::OnMouseWheelEventFinished()
1144 {
1145   if (mActiveLayout)
1146   {
1147     RemoveAnimation(mScrollAnimation);
1148
1149     // No more mouse wheel events coming. Do the anchoring if enabled.
1150     mScrollAnimation = DoAnchoring();
1151     if (mScrollAnimation)
1152     {
1153       mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1154       mScrollAnimation.Play();
1155     }
1156     else
1157     {
1158       mScrollOvershoot = 0.0f;
1159       AnimateScrollOvershoot(0.0f);
1160
1161       mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1162     }
1163   }
1164
1165   return false;
1166 }
1167
1168 void ItemView::ApplyConstraints(Actor& actor, ItemLayout& layout, unsigned int itemId, float duration)
1169 {
1170   ItemLayout::Vector3Function positionConstraint;
1171   if (layout.GetPositionConstraint(itemId, positionConstraint))
1172   {
1173     WrappedVector3Constraint wrapped(positionConstraint, itemId);
1174
1175     Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
1176                                                       Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1177                                                       ParentSource( mPropertyScrollSpeed ),
1178                                                       ParentSource( Actor::SIZE ),
1179                                                       wrapped );
1180     constraint.SetApplyTime(duration);
1181     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1182
1183     actor.ApplyConstraint(constraint);
1184   }
1185
1186   ItemLayout::QuaternionFunction rotationConstraint;
1187   if (layout.GetRotationConstraint(itemId, rotationConstraint))
1188   {
1189     WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
1190
1191     Constraint constraint = Constraint::New<Quaternion>( Actor::ROTATION,
1192                                                          Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1193                                                          ParentSource( mPropertyScrollSpeed ),
1194                                                          ParentSource( Actor::SIZE ),
1195                                                          wrapped );
1196     constraint.SetApplyTime(duration);
1197     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1198
1199     actor.ApplyConstraint(constraint);
1200   }
1201
1202   ItemLayout::Vector3Function scaleConstraint;
1203   if (layout.GetScaleConstraint(itemId, scaleConstraint))
1204   {
1205     WrappedVector3Constraint wrapped(scaleConstraint, itemId);
1206
1207     Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
1208                                                       Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1209                                                       ParentSource( mPropertyScrollSpeed ),
1210                                                       ParentSource( Actor::SIZE ),
1211                                                       wrapped );
1212     constraint.SetApplyTime(duration);
1213     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1214
1215     actor.ApplyConstraint(constraint);
1216   }
1217
1218   ItemLayout::Vector4Function colorConstraint;
1219   if (layout.GetColorConstraint(itemId, colorConstraint))
1220   {
1221     WrappedVector4Constraint wrapped(colorConstraint, itemId);
1222
1223     Constraint constraint = Constraint::New<Vector4>( Actor::COLOR,
1224                                                       Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1225                                                       ParentSource( mPropertyScrollSpeed ),
1226                                                       ParentSource( Actor::SIZE ),
1227                                                       wrapped );
1228     constraint.SetApplyTime(duration);
1229     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1230
1231     // Release color constraints slowly; this allows ItemView to co-exist with ImageActor fade-in
1232     constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
1233     constraint.SetRemoveAction(Dali::Constraint::Discard);
1234
1235     actor.ApplyConstraint(constraint);
1236   }
1237
1238   ItemLayout::BoolFunction visibilityConstraint;
1239   if (layout.GetVisibilityConstraint(itemId, visibilityConstraint))
1240   {
1241     WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
1242
1243     Constraint constraint = Constraint::New<bool>( Actor::VISIBLE,
1244                                                    Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
1245                                                    ParentSource( mPropertyScrollSpeed ),
1246                                                    ParentSource( Actor::SIZE ),
1247                                                    wrapped );
1248     constraint.SetApplyTime(duration);
1249     constraint.SetAlphaFunction(mDefaultAlphaFunction);
1250
1251     // Release visibility constraints the same time as the color constraint
1252     constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
1253     constraint.SetRemoveAction(Dali::Constraint::Discard);
1254
1255     actor.ApplyConstraint(constraint);
1256   }
1257 }
1258
1259 void ItemView::ReapplyAllConstraints( float durationSeconds )
1260 {
1261   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
1262   {
1263     unsigned int id = iter->first;
1264     Actor actor = iter->second;
1265
1266     actor.RemoveConstraints();
1267     ApplyConstraints(actor, *mActiveLayout, id, durationSeconds);
1268   }
1269
1270   CalculateDomainSize(Self().GetCurrentSize());
1271 }
1272
1273 float ItemView::ClampFirstItemPosition(float targetPosition, const Vector3& targetSize, ItemLayout& layout)
1274 {
1275   Actor self = Self();
1276   float minLayoutPosition = layout.GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), targetSize);
1277   float clamppedPosition = min(0.0f, max(minLayoutPosition, targetPosition));
1278   mScrollOvershoot = targetPosition - clamppedPosition;
1279   self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);
1280
1281   return clamppedPosition;
1282 }
1283
1284 void ItemView::OnPan(PanGesture gesture)
1285 {
1286   Actor self = Self();
1287   const Vector3 layoutSize = Self().GetCurrentSize();
1288
1289   RemoveAnimation(mScrollAnimation);
1290
1291   // Short-circuit if there is no active layout
1292   if (!mActiveLayout)
1293   {
1294     mGestureState = Gesture::Clear;
1295     return;
1296   }
1297
1298   mGestureState = gesture.state;
1299
1300   switch (mGestureState)
1301   {
1302     case Gesture::Finished:
1303     {
1304       // Swipe Detection
1305       if (fabsf(mScrollDistance) > mMinimumSwipeDistance &&
1306           mScrollSpeed > mMinimumSwipeSpeed)
1307       {
1308         float direction = (mScrollDistance < 0.0f) ? -1.0f : 1.0f;
1309
1310         mRefreshOrderHint = true;
1311
1312         float currentLayoutPosition = GetCurrentLayoutPosition(0);
1313         float firstItemScrollPosition = ClampFirstItemPosition(currentLayoutPosition + mScrollSpeed * direction,
1314                                                                layoutSize,
1315                                                                *mActiveLayout);
1316
1317         if (mAnchoringEnabled)
1318         {
1319           firstItemScrollPosition = mActiveLayout->GetClosestAnchorPosition(firstItemScrollPosition);
1320         }
1321
1322         RemoveAnimation(mScrollAnimation);
1323
1324         float flickAnimationDuration = mActiveLayout->GetItemFlickAnimationDuration() * max(1.0f, fabsf(firstItemScrollPosition - GetCurrentLayoutPosition(0)));
1325         mScrollAnimation = Animation::New(flickAnimationDuration);
1326         mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
1327         mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, layoutSize), AlphaFunctions::EaseOut );
1328         mScrollAnimation.AnimateTo( Property(self, mPropertyScrollSpeed), 0.0f, AlphaFunctions::EaseOut );
1329
1330         mIsFlicking = true;
1331         // Check whether it has already scrolled to the end
1332         if(fabs(currentLayoutPosition - firstItemScrollPosition) > Math::MACHINE_EPSILON_0)
1333         {
1334           AnimateScrollOvershoot(0.0f);
1335         }
1336       }
1337
1338       // Anchoring may be triggered when there was no swipe
1339       if (!mScrollAnimation)
1340       {
1341         mScrollAnimation = DoAnchoring();
1342       }
1343
1344       // Reset the overshoot if no scroll animation.
1345       if (!mScrollAnimation)
1346       {
1347         mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1348
1349         AnimateScrollOvershoot(0.0f, false);
1350       }
1351     }
1352     break;
1353
1354     case Gesture::Started: // Fall through
1355     {
1356       mTotalPanDisplacement = Vector2::ZERO;
1357       mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1358       mRefreshEnabled = true;
1359     }
1360
1361     case Gesture::Continuing:
1362     {
1363       mScrollDistance = CalculateScrollDistance(gesture.displacement, *mActiveLayout);
1364       mScrollSpeed = Clamp((gesture.GetSpeed() * mActiveLayout->GetFlickSpeedFactor() * MILLISECONDS_PER_SECONDS), 0.0f, mActiveLayout->GetMaximumSwipeSpeed());
1365
1366       // Refresh order depends on the direction of the scroll; negative is towards the last item.
1367       mRefreshOrderHint = mScrollDistance < 0.0f;
1368
1369       float layoutPositionDelta = GetCurrentLayoutPosition(0) + (mScrollDistance * mActiveLayout->GetScrollSpeedFactor());
1370
1371       float firstItemScrollPosition = ClampFirstItemPosition(layoutPositionDelta, layoutSize, *mActiveLayout);
1372
1373       mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1374       self.SetProperty(mPropertyPosition, GetScrollPosition(firstItemScrollPosition, layoutSize));
1375
1376       mTotalPanDisplacement += gesture.displacement;
1377       mScrollOvershoot = layoutPositionDelta - firstItemScrollPosition;
1378       if( mScrollOvershoot > Math::MACHINE_EPSILON_1 )
1379       {
1380         AnimateScrollOvershoot(1.0f);
1381       }
1382       else if( mScrollOvershoot < -Math::MACHINE_EPSILON_1 )
1383       {
1384         AnimateScrollOvershoot(-1.0f);
1385       }
1386       else
1387       {
1388         AnimateScrollOvershoot(0.0f);
1389       }
1390     }
1391     break;
1392
1393     case Gesture::Cancelled:
1394     {
1395       mScrollAnimation = DoAnchoring();
1396     }
1397     break;
1398
1399     default:
1400       break;
1401   }
1402
1403   if (mScrollAnimation)
1404   {
1405     mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1406     mScrollAnimation.Play();
1407   }
1408 }
1409
1410 bool ItemView::OnAccessibilityPan(PanGesture gesture)
1411 {
1412   OnPan(gesture);
1413   return true;
1414 }
1415
1416 Actor ItemView::GetNextKeyboardFocusableActor(Actor actor, Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
1417 {
1418   Actor nextFocusActor;
1419   if(mActiveLayout)
1420   {
1421     int nextItemID = 0;
1422     if(!actor || actor == this->Self())
1423     {
1424       nextFocusActor = GetItem(nextItemID);
1425     }
1426     else if(actor && actor.GetParent() == this->Self())
1427     {
1428       int itemID = GetItemId(actor);
1429       nextItemID = mActiveLayout->GetNextFocusItemID(itemID, mItemFactory.GetNumberOfItems(), direction, loopEnabled);
1430       nextFocusActor = GetItem(nextItemID);
1431       if(nextFocusActor == actor)
1432       {
1433         // need to pass NULL actor back to focus manager
1434         nextFocusActor.Reset();
1435         return nextFocusActor;
1436       }
1437     }
1438     float layoutPosition = mActiveLayout->GetClosestAnchorPosition( GetCurrentLayoutPosition(0) );
1439     Vector3 layoutSize = Self().GetCurrentSize();
1440     if(!nextFocusActor)
1441     {
1442       // likely the current item is not buffered, so not in our item pool, probably best to get first viewable item
1443       ItemRange viewableItems = mActiveLayout->GetItemsWithinArea(layoutPosition, layoutSize);
1444       nextItemID = viewableItems.begin;
1445       nextFocusActor = GetItem(nextItemID);
1446     }
1447   }
1448   return nextFocusActor;
1449 }
1450
1451 void ItemView::OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor)
1452 {
1453   // only in this function if our chosen focus actor was actually used
1454   if(commitedFocusableActor)
1455   {
1456     int nextItemID = GetItemId(commitedFocusableActor);
1457     float layoutPosition = GetCurrentLayoutPosition(0);
1458     Vector3 layoutSize = Self().GetCurrentSize();
1459     Vector3 focusItemPosition = Vector3::ZERO;
1460     ItemLayout::Vector3Function itemPositionConstraint;
1461     if (mActiveLayout->GetPositionConstraint(nextItemID, itemPositionConstraint))
1462     {
1463       focusItemPosition = itemPositionConstraint(Vector3::ZERO, layoutPosition + nextItemID, 0.0f, layoutSize);
1464     }
1465
1466     float scrollTo = mActiveLayout->GetClosestOnScreenLayoutPosition(nextItemID, layoutPosition, layoutSize);
1467     ScrollTo(Vector3(0.0f, scrollTo, 0.0f), DEFAULT_KEYBOARD_FOCUS_SCROLL_DURATION);
1468   }
1469 }
1470
1471 Animation ItemView::DoAnchoring()
1472 {
1473   Animation anchoringAnimation;
1474   Actor self = Self();
1475
1476   if (mActiveLayout && mAnchoringEnabled)
1477   {
1478     float anchorPosition = mActiveLayout->GetClosestAnchorPosition( GetCurrentLayoutPosition(0) );
1479
1480     anchoringAnimation = Animation::New(mAnchoringDuration);
1481     anchoringAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), anchorPosition, AlphaFunctions::EaseOut );
1482     anchoringAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(anchorPosition, self.GetCurrentSize()), AlphaFunctions::EaseOut );
1483     anchoringAnimation.AnimateTo( Property(self, mPropertyScrollSpeed), 0.0f, AlphaFunctions::EaseOut );
1484     if(!mIsFlicking)
1485     {
1486       AnimateScrollOvershoot(0.0f);
1487     }
1488   }
1489
1490   return anchoringAnimation;
1491 }
1492
1493 void ItemView::OnScrollFinished(Animation& source)
1494 {
1495   Actor self = Self();
1496
1497   RemoveAnimation(mScrollAnimation); // mScrollAnimation is used to query whether we're scrolling
1498
1499   mScrollCompletedSignalV2.Emit(GetCurrentScrollPosition());
1500
1501   if(mIsFlicking && fabsf(mScrollOvershoot) > Math::MACHINE_EPSILON_1)
1502   {
1503     AnimateScrollOvershoot( mScrollOvershoot > 0.0f ? 1.0f : -1.0f, true);
1504   }
1505   else
1506   {
1507     // Reset the overshoot
1508     AnimateScrollOvershoot( 0.0f );
1509   }
1510   mIsFlicking = false;
1511
1512   mScrollOvershoot = 0.0f;
1513 }
1514
1515 void ItemView::OnLayoutActivationScrollFinished(Animation& source)
1516 {
1517   mRefreshEnabled = true;
1518   DoRefresh(GetCurrentLayoutPosition(0), true);
1519 }
1520
1521 void ItemView::OnOvershootOnFinished(Animation& animation)
1522 {
1523   mAnimatingOvershootOn = false;
1524   mScrollOvershootAnimation.FinishedSignal().Disconnect(this, &ItemView::OnOvershootOnFinished);
1525   RemoveAnimation(mScrollOvershootAnimation);
1526   if(mAnimateOvershootOff)
1527   {
1528     AnimateScrollOvershoot(0.0f);
1529   }
1530 }
1531
1532 void ItemView::ScrollToItem(unsigned int itemId, float durationSeconds)
1533 {
1534   Actor self = Self();
1535   const Vector3 layoutSize = Self().GetCurrentSize();
1536   float firstItemScrollPosition = ClampFirstItemPosition(mActiveLayout->GetItemScrollToPosition(itemId), layoutSize, *mActiveLayout);
1537
1538   if(durationSeconds > 0.0f)
1539   {
1540     RemoveAnimation(mScrollAnimation);
1541     mScrollAnimation = Animation::New(durationSeconds);
1542     mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
1543     mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, layoutSize), AlphaFunctions::EaseOut );
1544     mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1545     mScrollAnimation.Play();
1546   }
1547   else
1548   {
1549     mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1550     AnimateScrollOvershoot(0.0f);
1551   }
1552
1553   mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1554   mRefreshEnabled = true;
1555 }
1556
1557 void ItemView::RemoveAnimation(Animation& animation)
1558 {
1559   if(animation)
1560   {
1561     // Cease animating, and reset handle.
1562     animation.Clear();
1563     animation.Reset();
1564   }
1565 }
1566
1567 void ItemView::CalculateDomainSize(const Vector3& layoutSize)
1568 {
1569   Actor self = Self();
1570
1571   Vector3 firstItemPosition(Vector3::ZERO);
1572   Vector3 lastItemPosition(Vector3::ZERO);
1573
1574   if(mActiveLayout)
1575   {
1576     ItemLayout::Vector3Function firstItemPositionConstraint;
1577     if (mActiveLayout->GetPositionConstraint(0, firstItemPositionConstraint))
1578     {
1579       firstItemPosition = firstItemPositionConstraint(Vector3::ZERO, 0, 0.0f, layoutSize);
1580     }
1581
1582     float minLayoutPosition = mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), layoutSize);
1583     self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);
1584
1585     ItemLayout::Vector3Function lastItemPositionConstraint;
1586     if (mActiveLayout->GetPositionConstraint(fabs(minLayoutPosition), lastItemPositionConstraint))
1587     {
1588       lastItemPosition = lastItemPositionConstraint(Vector3::ZERO, fabs(minLayoutPosition), 0.0f, layoutSize);
1589     }
1590
1591     float domainSize;
1592
1593     if(IsHorizontal(mActiveLayout->GetOrientation()))
1594     {
1595       self.SetProperty(mPropertyPositionMin, Vector3(0.0f, firstItemPosition.x, 0.0f));
1596       self.SetProperty(mPropertyPositionMax, Vector3(0.0f, lastItemPosition.x, 0.0f));
1597       domainSize = fabs(firstItemPosition.x - lastItemPosition.x);
1598     }
1599     else
1600     {
1601       self.SetProperty(mPropertyPositionMin, Vector3(0.0f, firstItemPosition.y, 0.0f));
1602       self.SetProperty(mPropertyPositionMax, Vector3(0.0f, lastItemPosition.y, 0.0f));
1603       domainSize = fabs(firstItemPosition.y - lastItemPosition.y);
1604     }
1605
1606     mScrollConnector.SetScrollDomain(minLayoutPosition, 0.0f, domainSize);
1607
1608     bool isLayoutScrollable = IsLayoutScrollable(layoutSize);
1609     self.SetProperty(mPropertyCanScrollVertical, isLayoutScrollable);
1610     self.SetProperty(mPropertyCanScrollHorizontal, false);
1611   }
1612 }
1613
1614 Vector3 ItemView::GetDomainSize() const
1615 {
1616   Actor self = Self();
1617
1618   float minScrollPosition = self.GetProperty<float>(mPropertyPositionMin);
1619   float maxScrollPosition = self.GetProperty<float>(mPropertyPositionMax);
1620
1621   return Vector3(0.0f, fabs(maxScrollPosition - minScrollPosition), 0.0f);
1622 }
1623
1624 bool ItemView::IsLayoutScrollable(const Vector3& layoutSize)
1625 {
1626   Actor self = Self();
1627
1628   float currentLayoutPosition = ClampFirstItemPosition( GetCurrentLayoutPosition(0), layoutSize, *mActiveLayout );
1629   float forwardClampedPosition = ClampFirstItemPosition(currentLayoutPosition + 1.0, layoutSize, *mActiveLayout);
1630   float backwardClampedPosition = ClampFirstItemPosition(currentLayoutPosition - 1.0, layoutSize, *mActiveLayout);
1631
1632   return (fabs(forwardClampedPosition - backwardClampedPosition) > Math::MACHINE_EPSILON_0);
1633 }
1634
1635 float ItemView::GetScrollPosition(float layoutPosition, const Vector3& layoutSize) const
1636 {
1637   Vector3 firstItemPosition(Vector3::ZERO);
1638   ItemLayout::Vector3Function firstItemPositionConstraint;
1639   if (mActiveLayout->GetPositionConstraint(0, firstItemPositionConstraint))
1640   {
1641     firstItemPosition = firstItemPositionConstraint(Vector3::ZERO, layoutPosition, 0.0f, layoutSize);
1642   }
1643
1644   return IsHorizontal(mActiveLayout->GetOrientation()) ? firstItemPosition.x: firstItemPosition.y;
1645 }
1646
1647 Vector3 ItemView::GetCurrentScrollPosition() const
1648 {
1649   float currentLayoutPosition = GetCurrentLayoutPosition(0);
1650   return Vector3(0.0f, GetScrollPosition(currentLayoutPosition, Self().GetCurrentSize()), 0.0f);
1651 }
1652
1653 void ItemView::AddOverlay(Actor actor)
1654 {
1655   Self().Add(actor);
1656 }
1657
1658 void ItemView::RemoveOverlay(Actor actor)
1659 {
1660   Self().Remove(actor);
1661 }
1662
1663 void ItemView::ScrollTo(const Vector3& position, float duration)
1664 {
1665   Actor self = Self();
1666   const Vector3 layoutSize = Self().GetCurrentSize();
1667
1668   float firstItemScrollPosition = ClampFirstItemPosition(position.y, layoutSize, *mActiveLayout);
1669
1670   if(duration > 0.0f)
1671   {
1672     RemoveAnimation(mScrollAnimation);
1673     mScrollAnimation = Animation::New(duration);
1674     mScrollAnimation.AnimateTo( Property( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ), firstItemScrollPosition, AlphaFunctions::EaseOut );
1675     mScrollAnimation.AnimateTo( Property(self, mPropertyPosition), GetScrollPosition(firstItemScrollPosition, layoutSize), AlphaFunctions::EaseOut );
1676     mScrollAnimation.FinishedSignal().Connect(this, &ItemView::OnScrollFinished);
1677     mScrollAnimation.Play();
1678   }
1679   else
1680   {
1681     mScrollPositionObject.SetProperty( ScrollConnector::SCROLL_POSITION, firstItemScrollPosition );
1682     AnimateScrollOvershoot(0.0f);
1683   }
1684
1685   mScrollStartedSignalV2.Emit(GetCurrentScrollPosition());
1686   mRefreshEnabled = true;
1687 }
1688
1689 void ItemView::SetOvershootEffectColor( const Vector4& color )
1690 {
1691   mOvershootEffectColor = color;
1692   if( mOvershootOverlay )
1693   {
1694     mOvershootOverlay.SetColor( color );
1695   }
1696 }
1697
1698 void ItemView::SetOvershootEnabled( bool enable )
1699 {
1700   Actor self = Self();
1701   if( enable )
1702   {
1703     Property::Index effectOvershootPropertyIndex = Property::INVALID_INDEX;
1704     mOvershootOverlay = CreateBouncingEffectActor( effectOvershootPropertyIndex );
1705     mOvershootOverlay.SetColor(mOvershootEffectColor);
1706     mOvershootOverlay.SetParentOrigin(ParentOrigin::TOP_LEFT);
1707     mOvershootOverlay.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1708     mOvershootOverlay.SetDrawMode(DrawMode::OVERLAY);
1709     self.Add(mOvershootOverlay);
1710
1711     Constraint constraint = Constraint::New<Vector3>( Actor::SIZE,
1712                                                       ParentSource( mPropertyScrollDirection ),
1713                                                       Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1714                                                       ParentSource( Actor::SIZE ),
1715                                                       OvershootOverlaySizeConstraint() );
1716     mOvershootOverlay.ApplyConstraint(constraint);
1717     mOvershootOverlay.SetSize(OVERSHOOT_BOUNCE_ACTOR_DEFAULT_SIZE.width, OVERSHOOT_BOUNCE_ACTOR_DEFAULT_SIZE.height);
1718
1719     constraint = Constraint::New<Quaternion>( Actor::ROTATION,
1720                                               ParentSource( mPropertyScrollDirection ),
1721                                               Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1722                                               OvershootOverlayRotationConstraint() );
1723     mOvershootOverlay.ApplyConstraint(constraint);
1724
1725     constraint = Constraint::New<Vector3>( Actor::POSITION,
1726                                            ParentSource( Actor::SIZE ),
1727                                            ParentSource( mPropertyScrollDirection ),
1728                                            Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1729                                            OvershootOverlayPositionConstraint() );
1730     mOvershootOverlay.ApplyConstraint(constraint);
1731
1732     constraint = Constraint::New<bool>( Actor::VISIBLE,
1733                                         ParentSource( mPropertyCanScrollVertical ),
1734                                         OvershootOverlayVisibilityConstraint() );
1735     mOvershootOverlay.ApplyConstraint(constraint);
1736
1737     Actor self = Self();
1738     constraint = Constraint::New<float>( effectOvershootPropertyIndex,
1739                                          Source( mScrollPositionObject, ScrollConnector::OVERSHOOT ),
1740                                          EqualToConstraint() );
1741     mOvershootOverlay.ApplyConstraint(constraint);
1742   }
1743   else
1744   {
1745     if( mOvershootOverlay )
1746     {
1747       self.Remove(mOvershootOverlay);
1748       mOvershootOverlay.Reset();
1749     }
1750   }
1751 }
1752
1753 float ItemView::CalculateScrollOvershoot()
1754 {
1755   float overshoot = 0.0f;
1756
1757   if(mActiveLayout)
1758   {
1759     // The overshoot must be calculated from the accumulated pan gesture displacement
1760     // since the pan gesture starts.
1761     Actor self = Self();
1762     float scrollDistance = CalculateScrollDistance(mTotalPanDisplacement, *mActiveLayout) * mActiveLayout->GetScrollSpeedFactor();
1763     float positionDelta = GetCurrentLayoutPosition(0) + scrollDistance;
1764     float minLayoutPosition = mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), Self().GetCurrentSize());
1765     self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);
1766     float clamppedPosition = min(0.0f, max(minLayoutPosition, positionDelta));
1767     overshoot = positionDelta - clamppedPosition;
1768   }
1769
1770   return overshoot;
1771 }
1772
1773 void ItemView::AnimateScrollOvershoot(float overshootAmount, bool animateBack)
1774 {
1775   bool animatingOn = fabsf(overshootAmount) > Math::MACHINE_EPSILON_1;
1776
1777   // make sure we animate back if needed
1778   mAnimateOvershootOff = animateBack || (!animatingOn && mAnimatingOvershootOn);
1779
1780   if( mAnimatingOvershootOn )
1781   {
1782     // animating on, do not allow animate off
1783     return;
1784   }
1785
1786   Actor self = Self();
1787   float currentOvershoot = mScrollPositionObject.GetProperty<float>(ScrollConnector::OVERSHOOT);
1788   float duration = DEFAULT_OVERSHOOT_ANIMATION_DURATION * (animatingOn ? (1.0f - fabsf(currentOvershoot)) : fabsf(currentOvershoot));
1789
1790   RemoveAnimation(mScrollOvershootAnimation);
1791   mScrollOvershootAnimation = Animation::New(duration);
1792   mScrollOvershootAnimation.FinishedSignal().Connect(this, &ItemView::OnOvershootOnFinished);
1793   mScrollOvershootAnimation.AnimateTo( Property(mScrollPositionObject, ScrollConnector::OVERSHOOT), overshootAmount, TimePeriod(0.0f, duration) );
1794   mScrollOvershootAnimation.Play();
1795
1796   mAnimatingOvershootOn = animatingOn;
1797 }
1798
1799 void ItemView::SetItemsParentOrigin( const Vector3& parentOrigin )
1800 {
1801   if( parentOrigin != mItemsParentOrigin )
1802   {
1803     mItemsParentOrigin = parentOrigin;
1804     for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
1805     {
1806       iter->second.SetParentOrigin(parentOrigin);
1807     }
1808   }
1809 }
1810
1811 Vector3 ItemView::GetItemsParentOrigin() const
1812 {
1813   return mItemsParentOrigin;
1814 }
1815
1816 void ItemView::SetItemsAnchorPoint( const Vector3& anchorPoint )
1817 {
1818   if( anchorPoint != mItemsAnchorPoint )
1819   {
1820     mItemsAnchorPoint = anchorPoint;
1821     for (ItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
1822     {
1823       iter->second.SetAnchorPoint(anchorPoint);
1824     }
1825   }
1826 }
1827
1828 Vector3 ItemView::GetItemsAnchorPoint() const
1829 {
1830   return mItemsAnchorPoint;
1831 }
1832
1833 void ItemView::GetItemsRange(ItemRange& range)
1834 {
1835   range.begin = mItemPool.begin()->first;
1836   range.end = mItemPool.rbegin()->first + 1;
1837 }
1838
1839 } // namespace Internal
1840
1841 } // namespace Toolkit
1842
1843 } // namespace Dali