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