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