dali-toolkit/internal/controls/scroll-bar/scroll-bar-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/scroll-bar/scroll-bar-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/animation/constraints.h>
  23 #include <dali/public-api/object/type-registry.h>
  24 #include <dali/public-api/images/resource-image.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h>
  28
  29 using namespace Dali;
  30
  31 namespace
  32 {
  33
  34 const char* DEFAULT_INDICATOR_IMAGE_PATH = DALI_IMAGE_DIR "popup_scroll.png";
  35 const Vector4 DEFAULT_INDICATOR_NINE_PATCH_BORDER(4.0f, 9.0f, 7.0f, 11.0f);
  36 const float MINIMUM_INDICATOR_HEIGHT(20.0f); // The minimum indicator height for the nine patch border
  37 const float DEFAULT_SLIDER_DEPTH(1.0f);
  38 const float DEFAULT_INDICATOR_SHOW_DURATION(0.5f);
  39 const float DEFAULT_INDICATOR_HIDE_DURATION(0.5f);
  40 const float DEFAULT_PAN_GESTURE_PROCESS_TIME(16.7f); // 16.7 milliseconds, i.e. one frame
  41 const float DEFAULT_INDICATOR_FIXED_HEIGHT(80.0f);
  42
  43 /**
  44  * Indicator size depends on both indicator's parent size and the scroll content size
  45  */
  46 Vector3 IndicatorSize( const Vector3& parentSize, float contentSize)
  47 {
  48   float height = contentSize > parentSize.height ?
  49                  parentSize.height * ( parentSize.height / contentSize ) :
  50                  parentSize.height * ( (parentSize.height - contentSize * 0.5f) / parentSize.height);
  51   return Vector3( parentSize.width, std::max(MINIMUM_INDICATOR_HEIGHT, height), parentSize.depth );
  52 }
  53
  54 /**
  55  * Indicator position constraint
  56  * Positions the indicator to reflect the current scroll position within the scroll domain.
  57  */
  58 struct IndicatorPositionConstraint
  59 {
  60   /**
  61    * @param[in] minPosition The minimum limit of scroll position
  62    * @param[in] maxPosition the maximum limit of scroll position
  63    */
  64   IndicatorPositionConstraint(float minPosition, float maxPosition)
  65   : mMinPosition(minPosition),
  66     mMaxPosition(maxPosition)
  67   {
  68   }
  69
  70   /**
  71    * Constraint operator
  72    * @param[in] current The current indicator position
  73    * @param[in] indicatorSizeProperty The size of indicator.
  74    * @param[in] parentSizeProperty The parent size of indicator.
  75    * @param[in] scrollPositionProperty The scroll position of the scrollable container // (from 0.0 -> 1.0 in each axis)
  76    * @return The new indicator position is returned.
  77    */
  78   Vector3 operator()(const Vector3& current,
  79                      const PropertyInput& indicatorSizeProperty,
  80                      const PropertyInput& parentSizeProperty,
  81                      const PropertyInput& scrollPositionProperty)
  82   {
  83     Vector3 indicatorSize = indicatorSizeProperty.GetVector3();
  84     Vector3 parentSize = parentSizeProperty.GetVector3();
  85     float scrollPosition = scrollPositionProperty.GetFloat();
  86
  87     const float domainSize = fabs(mMaxPosition - mMinPosition);
  88     float relativePosition = (mMaxPosition - scrollPosition) / domainSize;
  89     return Vector3(current.x, relativePosition * (parentSize.height - indicatorSize.height), DEFAULT_SLIDER_DEPTH);
  90   }
  91
  92   float mMinPosition;  ///< The minimum scroll position
  93   float mMaxPosition;  ///< The maximum scroll position
  94 };
  95
  96 } // unnamed namespace
  97
  98 namespace Dali
  99 {
 100
 101 namespace Toolkit
 102 {
 103
 104 const Property::Index ScrollBar::PROPERTY_INDICATOR_HEIGHT_POLICY( Internal::ScrollBar::SCROLLBAR_PROPERTY_START_INDEX );
 105 const Property::Index ScrollBar::PROPERTY_INDICATOR_FIXED_HEIGHT( Internal::ScrollBar::SCROLLBAR_PROPERTY_START_INDEX + 1 );
 106 const Property::Index ScrollBar::PROPERTY_INDICATOR_SHOW_DURATION( Internal::ScrollBar::SCROLLBAR_PROPERTY_START_INDEX + 2 );
 107 const Property::Index ScrollBar::PROPERTY_INDICATOR_HIDE_DURATION( Internal::ScrollBar::SCROLLBAR_PROPERTY_START_INDEX + 3 );
 108
 109 namespace Internal
 110 {
 111
 112 namespace
 113 {
 114
 115 using namespace Dali;
 116
 117 const char* INDICATOR_HEIGHT_POLICY_NAME[] = {"Variable", "Fixed"};
 118
 119 BaseHandle Create()
 120 {
 121   return Toolkit::ScrollBar::New();
 122 }
 123
 124 TypeRegistration typeRegistration( typeid( Toolkit::ScrollBar ), typeid( Toolkit::ScrollComponent ), Create );
 125
 126 const char* const SCROLL_POSITION_NOTIFIED_SIGNAL_NAME = "scroll-position-notified";
 127
 128 PropertyRegistration property1( typeRegistration, "indicator-height-policy", Toolkit::ScrollBar::PROPERTY_INDICATOR_HEIGHT_POLICY, Property::STRING, &ScrollBar::SetProperty, &ScrollBar::GetProperty );
 129 PropertyRegistration property2( typeRegistration, "indicator-fixed-height",  Toolkit::ScrollBar::PROPERTY_INDICATOR_FIXED_HEIGHT,  Property::FLOAT,  &ScrollBar::SetProperty, &ScrollBar::GetProperty );
 130 PropertyRegistration property3( typeRegistration, "indicator-show-duration",  Toolkit::ScrollBar::PROPERTY_INDICATOR_SHOW_DURATION,  Property::FLOAT,  &ScrollBar::SetProperty, &ScrollBar::GetProperty );
 131 PropertyRegistration property4( typeRegistration, "indicator-hide-duration",  Toolkit::ScrollBar::PROPERTY_INDICATOR_HIDE_DURATION,  Property::FLOAT,  &ScrollBar::SetProperty, &ScrollBar::GetProperty );
 132 }
 133
 134 ScrollBar::ScrollBar()
 135 : mIndicatorShowDuration(DEFAULT_INDICATOR_SHOW_DURATION),
 136   mIndicatorHideDuration(DEFAULT_INDICATOR_HIDE_DURATION),
 137   mScrollStart(0.0f),
 138   mIsPanning(false),
 139   mCurrentScrollPosition(0.0f),
 140   mIndicatorHeightPolicy(Toolkit::ScrollBar::Variable),
 141   mIndicatorFixedHeight(DEFAULT_INDICATOR_FIXED_HEIGHT),
 142   mPropertyIndicatorPosition(Property::INVALID_INDEX)
 143 {
 144 }
 145
 146 ScrollBar::~ScrollBar()
 147 {
 148 }
 149
 150 void ScrollBar::OnInitialize()
 151 {
 152   Actor self = Self();
 153
 154   Image indicatorImage = ResourceImage::New( DEFAULT_INDICATOR_IMAGE_PATH );
 155   mIndicator = ImageActor::New( indicatorImage );
 156   mIndicator.SetNinePatchBorder( DEFAULT_INDICATOR_NINE_PATCH_BORDER );
 157   mIndicator.SetStyle( ImageActor::STYLE_NINE_PATCH );
 158   mIndicator.SetParentOrigin( ParentOrigin::TOP_LEFT );
 159   mIndicator.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 160   self.Add(mIndicator);
 161
 162   self.SetDrawMode(DrawMode::OVERLAY);
 163
 164   // Enable the pan gesture which is attached to the control
 165   EnableGestureDetection(Gesture::Type(Gesture::Pan));
 166 }
 167
 168 void ScrollBar::OnScrollConnectorSet( Toolkit::ScrollConnector oldConnector )
 169 {
 170   if( oldConnector )
 171   {
 172     oldConnector.DomainChangedSignal().Disconnect(this, &ScrollBar::OnScrollDomainChanged);
 173
 174     mScrollPositionObject.Reset();
 175   }
 176
 177   if( mScrollConnector )
 178   {
 179     mScrollPositionObject = mScrollConnector.GetScrollPositionObject();
 180
 181     ApplyConstraints();
 182     mScrollConnector.DomainChangedSignal().Connect(this, &ScrollBar::OnScrollDomainChanged);
 183   }
 184 }
 185
 186 void ScrollBar::SetIndicatorImage( Image image )
 187 {
 188   mIndicator.SetImage(image);
 189 }
 190
 191 Actor ScrollBar::GetScrollIndicator()
 192 {
 193   return mIndicator;
 194 }
 195
 196 void ScrollBar::ApplyConstraints()
 197 {
 198   if( mScrollConnector )
 199   {
 200     Constraint constraint;
 201
 202     if(mIndicatorSizeConstraint)
 203     {
 204       mIndicator.RemoveConstraint(mIndicatorSizeConstraint);
 205     }
 206
 207     // Set indicator height according to the indicator's height policy
 208     if(mIndicatorHeightPolicy == Toolkit::ScrollBar::Fixed)
 209     {
 210       mIndicator.SetSize(Self().GetCurrentSize().width, mIndicatorFixedHeight);
 211     }
 212     else
 213     {
 214       mIndicator.SetSize( IndicatorSize( Self().GetCurrentSize(), mScrollConnector.GetContentLength() ) );
 215     }
 216
 217     if(mIndicatorPositionConstraint)
 218     {
 219       mIndicator.RemoveConstraint(mIndicatorPositionConstraint);
 220     }
 221
 222     constraint = Constraint::New<Vector3>( Actor::POSITION,
 223                                            LocalSource( Actor::SIZE ),
 224                                            ParentSource( Actor::SIZE ),
 225                                            Source( mScrollPositionObject, Toolkit::ScrollConnector::SCROLL_POSITION ),
 226                                            IndicatorPositionConstraint( mScrollConnector.GetMinLimit(), mScrollConnector.GetMaxLimit() ) );
 227     mIndicatorPositionConstraint = mIndicator.ApplyConstraint( constraint );
 228   }
 229 }
 230
 231 void ScrollBar::SetPositionNotifications( const std::vector<float>& positions )
 232 {
 233   if(mScrollPositionObject)
 234   {
 235     if(mPositionNotification)
 236     {
 237       mScrollPositionObject.RemovePropertyNotification(mPositionNotification);
 238     }
 239     mPositionNotification = mScrollPositionObject.AddPropertyNotification( Toolkit::ScrollConnector::SCROLL_POSITION, VariableStepCondition(positions) );
 240     mPositionNotification.NotifySignal().Connect( this, &ScrollBar::OnScrollPositionNotified );
 241   }
 242 }
 243
 244 void ScrollBar::OnScrollPositionNotified(PropertyNotification& source)
 245 {
 246   // Emit the signal to notify the scroll position crossing
 247   mScrollPositionNotifiedSignal.Emit(mScrollConnector.GetScrollPosition());
 248 }
 249
 250 void ScrollBar::Show()
 251 {
 252   // Cancel any animation
 253   if(mAnimation)
 254   {
 255     mAnimation.Clear();
 256     mAnimation.Reset();
 257   }
 258
 259   if(mIndicatorShowDuration > 0.0f)
 260   {
 261     mAnimation = Animation::New( mIndicatorShowDuration );
 262     mAnimation.OpacityTo( Self(), 1.0f, AlphaFunctions::EaseIn );
 263     mAnimation.Play();
 264   }
 265   else
 266   {
 267     Self().SetOpacity(1.0f);
 268   }
 269 }
 270
 271 void ScrollBar::Hide()
 272 {
 273   // Cancel any animation
 274   if(mAnimation)
 275   {
 276     mAnimation.Clear();
 277     mAnimation.Reset();
 278   }
 279
 280   if(mIndicatorHideDuration > 0.0f)
 281   {
 282     mAnimation = Animation::New( mIndicatorHideDuration );
 283     mAnimation.OpacityTo( Self(), 0.0f, AlphaFunctions::EaseIn );
 284     mAnimation.Play();
 285   }
 286   else
 287   {
 288     Self().SetOpacity(0.0f);
 289   }
 290 }
 291
 292 bool ScrollBar::OnPanGestureProcessTick()
 293 {
 294   // Update the scroll position property.
 295   if( mScrollConnector )
 296   {
 297     mScrollConnector.SetScrollPosition(mCurrentScrollPosition);
 298   }
 299
 300   return true;
 301 }
 302
 303 void ScrollBar::OnPan( PanGesture gesture )
 304 {
 305   if(mScrollConnector)
 306   {
 307     Dali::Toolkit::ItemView itemView = Dali::Toolkit::ItemView::DownCast(Self().GetParent());
 308
 309     switch(gesture.state)
 310     {
 311       case Gesture::Started:
 312       {
 313         if( !mTimer )
 314         {
 315           // Make sure the pan gesture is only being processed once per frame.
 316           mTimer = Timer::New( DEFAULT_PAN_GESTURE_PROCESS_TIME );
 317           mTimer.TickSignal().Connect( this, &ScrollBar::OnPanGestureProcessTick );
 318           mTimer.Start();
 319         }
 320
 321         Show();
 322         mScrollStart = mScrollConnector.GetScrollPosition();
 323         mGestureDisplacement = Vector3::ZERO;
 324         mIsPanning = true;
 325
 326         break;
 327       }
 328       case Gesture::Continuing:
 329       {
 330         Vector3 delta(gesture.displacement.x, gesture.displacement.y, 0.0f);
 331         mGestureDisplacement+=delta;
 332
 333         Vector3 span = Self().GetCurrentSize() - mIndicator.GetCurrentSize();
 334         const float domainSize = fabs(mScrollConnector.GetMaxLimit() - mScrollConnector.GetMinLimit());
 335         mCurrentScrollPosition = mScrollStart - mGestureDisplacement.y * domainSize / span.y;
 336         mCurrentScrollPosition = std::min(mScrollConnector.GetMaxLimit(), std::max(mCurrentScrollPosition, mScrollConnector.GetMinLimit()));
 337
 338         break;
 339       }
 340       default:
 341       {
 342         mIsPanning = false;
 343
 344         if( mTimer )
 345         {
 346           // Destroy the timer when pan gesture is finished.
 347           mTimer.Stop();
 348           mTimer.TickSignal().Disconnect( this, &ScrollBar::OnPanGestureProcessTick );
 349           mTimer.Reset();
 350         }
 351
 352         if(itemView)
 353         {
 354           // Refresh the ItemView cache with extra items
 355           GetImpl(itemView).DoRefresh(mCurrentScrollPosition, true);
 356         }
 357
 358         break;
 359       }
 360     }
 361
 362     if(itemView)
 363     {
 364       // Disable automatic refresh in ItemView during fast scrolling
 365       GetImpl(itemView).SetRefreshEnabled(!mIsPanning);
 366     }
 367   }
 368 }
 369
 370 void ScrollBar::OnControlSizeSet( const Vector3& size )
 371 {
 372   if(mIndicatorHeightPolicy != Toolkit::ScrollBar::Fixed && mScrollConnector)
 373   {
 374     mIndicator.SetSize( IndicatorSize( size, mScrollConnector.GetContentLength() ) );
 375   }
 376 }
 377
 378 void ScrollBar::OnScrollDomainChanged(float minPosition, float maxPosition, float contentSize)
 379 {
 380   // Reapply constraints when the scroll domain is changed
 381   ApplyConstraints();
 382 }
 383
 384 void ScrollBar::SetIndicatorHeightPolicy( Toolkit::ScrollBar::IndicatorHeightPolicy policy )
 385 {
 386   mIndicatorHeightPolicy = policy;
 387   ApplyConstraints();
 388 }
 389
 390 Toolkit::ScrollBar::IndicatorHeightPolicy ScrollBar::GetIndicatorHeightPolicy()
 391 {
 392   return mIndicatorHeightPolicy;
 393 }
 394
 395 void ScrollBar::SetIndicatorFixedHeight( float height )
 396 {
 397   mIndicatorFixedHeight = height;
 398   ApplyConstraints();
 399 }
 400
 401 float ScrollBar::GetIndicatorFixedHeight()
 402 {
 403   return mIndicatorFixedHeight;
 404 }
 405
 406 void ScrollBar::SetIndicatorShowDuration( float durationSeconds )
 407 {
 408   mIndicatorShowDuration = durationSeconds;
 409 }
 410
 411 float ScrollBar::GetIndicatorShowDuration()
 412 {
 413   return mIndicatorShowDuration;
 414 }
 415
 416 void ScrollBar::SetIndicatorHideDuration( float durationSeconds )
 417 {
 418   mIndicatorHideDuration = durationSeconds;
 419 }
 420
 421 float ScrollBar::GetIndicatorHideDuration()
 422 {
 423   return mIndicatorHideDuration;
 424 }
 425
 426 void ScrollBar::OnIndicatorHeightPolicyPropertySet( Property::Value propertyValue )
 427 {
 428   std::string policyName( propertyValue.Get<std::string>() );
 429   if(policyName == "Variable")
 430   {
 431     SetIndicatorHeightPolicy(Toolkit::ScrollBar::Variable);
 432   }
 433   else if(policyName == "Fixed")
 434   {
 435     SetIndicatorHeightPolicy(Toolkit::ScrollBar::Fixed);
 436   }
 437   else
 438   {
 439     DALI_ASSERT_ALWAYS( !"ScrollBar::OnIndicatorHeightPolicyPropertySet(). Invalid Property value." );
 440   }
 441 }
 442
 443 bool ScrollBar::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 444 {
 445   Dali::BaseHandle handle( object );
 446
 447   bool connected( true );
 448   Toolkit::ScrollBar scrollBar = Toolkit::ScrollBar::DownCast( handle );
 449
 450   if( 0 == strcmp( signalName.c_str(), SCROLL_POSITION_NOTIFIED_SIGNAL_NAME ) )
 451   {
 452     scrollBar.ScrollPositionNotifiedSignal().Connect( tracker, functor );
 453   }
 454   else
 455   {
 456     // signalName does not match any signal
 457     connected = false;
 458   }
 459
 460   return connected;
 461 }
 462
 463 void ScrollBar::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 464 {
 465   Toolkit::ScrollBar scrollBar = Toolkit::ScrollBar::DownCast( Dali::BaseHandle( object ) );
 466
 467   if( scrollBar )
 468   {
 469     ScrollBar& scrollBarImpl( GetImpl( scrollBar ) );
 470     switch( index )
 471     {
 472       case Toolkit::ScrollBar::PROPERTY_INDICATOR_HEIGHT_POLICY:
 473       {
 474         scrollBarImpl.OnIndicatorHeightPolicyPropertySet( value );
 475         break;
 476       }
 477       case Toolkit::ScrollBar::PROPERTY_INDICATOR_FIXED_HEIGHT:
 478       {
 479         scrollBarImpl.SetIndicatorFixedHeight(value.Get<float>());
 480         break;
 481       }
 482       case Toolkit::ScrollBar::PROPERTY_INDICATOR_SHOW_DURATION:
 483       {
 484         scrollBarImpl.SetIndicatorShowDuration(value.Get<float>());
 485         break;
 486       }
 487       case Toolkit::ScrollBar::PROPERTY_INDICATOR_HIDE_DURATION:
 488       {
 489         scrollBarImpl.SetIndicatorHideDuration(value.Get<float>());
 490         break;
 491       }
 492     }
 493   }
 494 }
 495
 496 Property::Value ScrollBar::GetProperty( BaseObject* object, Property::Index index )
 497 {
 498   Property::Value value;
 499
 500   Toolkit::ScrollBar scrollBar = Toolkit::ScrollBar::DownCast( Dali::BaseHandle( object ) );
 501
 502   if( scrollBar )
 503   {
 504     ScrollBar& scrollBarImpl( GetImpl( scrollBar ) );
 505     switch( index )
 506     {
 507       case Toolkit::ScrollBar::PROPERTY_INDICATOR_HEIGHT_POLICY:
 508       {
 509         value = INDICATOR_HEIGHT_POLICY_NAME[ scrollBarImpl.GetIndicatorHeightPolicy() ];
 510         break;
 511       }
 512       case Toolkit::ScrollBar::PROPERTY_INDICATOR_FIXED_HEIGHT:
 513       {
 514         value = scrollBarImpl.GetIndicatorFixedHeight();
 515         break;
 516       }
 517       case Toolkit::ScrollBar::PROPERTY_INDICATOR_SHOW_DURATION:
 518       {
 519         value = scrollBarImpl.GetIndicatorShowDuration();
 520         break;
 521       }
 522       case Toolkit::ScrollBar::PROPERTY_INDICATOR_HIDE_DURATION:
 523       {
 524         value = scrollBarImpl.GetIndicatorHideDuration();
 525         break;
 526       }
 527     }
 528   }
 529   return value;
 530 }
 531
 532 Toolkit::ScrollBar ScrollBar::New()
 533 {
 534   // Create the implementation, temporarily owned by this handle on stack
 535   IntrusivePtr< ScrollBar > impl = new ScrollBar();
 536
 537   // Pass ownership to CustomActor handle
 538   Toolkit::ScrollBar handle( *impl );
 539
 540   // Second-phase init of the implementation
 541   // This can only be done after the CustomActor connection has been made...
 542   impl->Initialize();
 543
 544   return handle;
 545 }
 546
 547 } // namespace Internal
 548
 549 } // namespace Toolkit
 550
 551 } // namespace Dali