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