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