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/images/resource-image.h>
  26 #include <dali/public-api/object/type-registry.h>
  27 #include <dali/public-api/object/property-array.h>
  28 #include <dali/devel-api/object/type-registry-helper.h>
  29 #include <dali/integration-api/debug.h>
  30
  31
  32 // INTERNAL INCLUDES
  33 #include <dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h>
  34
  35 using namespace Dali;
  36
  37 namespace
  38 {
  39
  40 const char* DEFAULT_INDICATOR_IMAGE_PATH = DALI_IMAGE_DIR "popup_scroll.png";
  41 const Vector4 DEFAULT_INDICATOR_NINE_PATCH_BORDER(4.0f, 9.0f, 7.0f, 11.0f);
  42 const float MINIMUM_INDICATOR_HEIGHT(20.0f); // The minimum indicator height for the nine patch border
  43 const float DEFAULT_SLIDER_DEPTH(1.0f);
  44 const float DEFAULT_INDICATOR_SHOW_DURATION(0.5f);
  45 const float DEFAULT_INDICATOR_HIDE_DURATION(0.5f);
  46 const float DEFAULT_PAN_GESTURE_PROCESS_TIME(16.7f); // 16.7 milliseconds, i.e. one frame
  47 const float DEFAULT_INDICATOR_FIXED_HEIGHT(80.0f);
  48
  49 /**
  50  * Indicator size constraint
  51  * Indicator size depends on both indicator's parent size and the scroll content size
  52  */
  53 struct IndicatorSizeConstraint
  54 {
  55   IndicatorSizeConstraint()
  56   {
  57   }
  58
  59   /**
  60    * Constraint operator
  61    * @param[in] current The current indicator size
  62    * @param[in] parentSizeProperty The parent size of scroll indicator.
  63    * @return The new scroll indicator size.
  64    */
  65   void operator()(Vector3& current, const PropertyInputContainer& inputs )
  66   {
  67     const Vector3& parentSize = inputs[0]->GetVector3();
  68     const float contentSize = inputs[1]->GetFloat();
  69
  70     float height = contentSize > parentSize.height ?
  71                    parentSize.height * ( parentSize.height / contentSize ) :
  72                    parentSize.height * ( (parentSize.height - contentSize * 0.5f) / parentSize.height);
  73
  74     current.y = std::max(MINIMUM_INDICATOR_HEIGHT, height);
  75   }
  76 };
  77
  78 /**
  79  * Indicator position constraint
  80  * Positions the indicator to reflect the current scroll position within the scroll domain.
  81  */
  82 struct IndicatorPositionConstraint
  83 {
  84   /**
  85    * @param[in] minPosition The minimum limit of scroll position
  86    * @param[in] maxPosition the maximum limit of scroll position
  87    */
  88   IndicatorPositionConstraint()
  89   {
  90   }
  91
  92   /**
  93    * Constraint operator
  94    * @param[in,out] current The current indicator position
  95    * @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)
  96    * @return The new indicator position is returned.
  97    */
  98   void operator()( Vector3& current, const PropertyInputContainer& inputs )
  99   {
 100     const Vector3& indicatorSize = inputs[0]->GetVector3();
 101     const Vector3& parentSize = inputs[1]->GetVector3();
 102     const float scrollPosition = -inputs[2]->GetFloat();
 103     const float minScrollPosition = inputs[3]->GetFloat();
 104     const float maxScrollPosition = inputs[4]->GetFloat();
 105
 106     float relativePosition = std::max( 0.0f, std::min( 1.0f, (scrollPosition - minScrollPosition) / (maxScrollPosition - minScrollPosition) ) );
 107     current.y = ( parentSize.height - indicatorSize.height ) * relativePosition;
 108     current.z = DEFAULT_SLIDER_DEPTH;
 109   }
 110 };
 111
 112 } // unnamed namespace
 113
 114 namespace Dali
 115 {
 116
 117 namespace Toolkit
 118 {
 119
 120 namespace Internal
 121 {
 122
 123 namespace
 124 {
 125
 126 using namespace Dali;
 127
 128 BaseHandle Create()
 129 {
 130   return Toolkit::ScrollBar::New();
 131 }
 132
 133 // Setup properties, signals and actions using the type-registry.
 134 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ScrollBar, Toolkit::Control, Create );
 135
 136 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "scroll-direction",                  STRING, SCROLL_DIRECTION          )
 137 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-height-policy",           STRING, INDICATOR_HEIGHT_POLICY   )
 138 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-fixed-height",            FLOAT,  INDICATOR_FIXED_HEIGHT    )
 139 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-show-duration",           FLOAT,  INDICATOR_SHOW_DURATION   )
 140 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "indicator-hide-duration",           FLOAT,  INDICATOR_HIDE_DURATION   )
 141 DALI_PROPERTY_REGISTRATION( Toolkit, ScrollBar, "scroll-position-intervals",         ARRAY,  SCROLL_POSITION_INTERVALS )
 142
 143 DALI_SIGNAL_REGISTRATION(   Toolkit, ScrollBar, "pan-finished",                      PAN_FINISHED_SIGNAL )
 144 DALI_SIGNAL_REGISTRATION(   Toolkit, ScrollBar, "scroll-position-interval-reached",  SCROLL_POSITION_INTERVAL_REACHED_SIGNAL )
 145
 146 DALI_TYPE_REGISTRATION_END()
 147
 148 const char* SCROLL_DIRECTION_NAME[] = {"Vertical", "Horizontal"};
 149 const char* INDICATOR_HEIGHT_POLICY_NAME[] = {"Variable", "Fixed"};
 150
 151 }
 152
 153 ScrollBar::ScrollBar(Toolkit::ScrollBar::Direction direction)
 154 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
 155   mDirection(direction),
 156   mScrollableObject(Handle()),
 157   mPropertyScrollPosition(Property::INVALID_INDEX),
 158   mPropertyMinScrollPosition(Property::INVALID_INDEX),
 159   mPropertyMaxScrollPosition(Property::INVALID_INDEX),
 160   mPropertyScrollContentSize(Property::INVALID_INDEX),
 161   mIndicatorShowDuration(DEFAULT_INDICATOR_SHOW_DURATION),
 162   mIndicatorHideDuration(DEFAULT_INDICATOR_HIDE_DURATION),
 163   mScrollStart(0.0f),
 164   mIsPanning(false),
 165   mCurrentScrollPosition(0.0f),
 166   mIndicatorHeightPolicy(Toolkit::ScrollBar::Variable),
 167   mIndicatorFixedHeight(DEFAULT_INDICATOR_FIXED_HEIGHT)
 168 {
 169 }
 170
 171 ScrollBar::~ScrollBar()
 172 {
 173 }
 174
 175 void ScrollBar::OnInitialize()
 176 {
 177   CreateDefaultIndicatorActor();
 178 }
 179
 180 void ScrollBar::SetScrollPropertySource( Handle handle, Property::Index propertyScrollPosition, Property::Index propertyMinScrollPosition, Property::Index propertyMaxScrollPosition, Property::Index propertyScrollContentSize )
 181 {
 182   if( handle
 183       && propertyScrollPosition != Property::INVALID_INDEX
 184       && propertyMinScrollPosition != Property::INVALID_INDEX
 185       && propertyMaxScrollPosition != Property::INVALID_INDEX
 186       && propertyScrollContentSize != Property::INVALID_INDEX )
 187   {
 188     mScrollableObject = handle;
 189     mPropertyScrollPosition = propertyScrollPosition;
 190     mPropertyMinScrollPosition = propertyMinScrollPosition;
 191     mPropertyMaxScrollPosition = propertyMaxScrollPosition;
 192     mPropertyScrollContentSize = propertyScrollContentSize;
 193
 194     ApplyConstraints();
 195   }
 196   else
 197   {
 198     DALI_LOG_ERROR("Can not set empty handle of source object or invalid source property index\n");
 199   }
 200 }
 201
 202 void ScrollBar::CreateDefaultIndicatorActor()
 203 {
 204   Image indicatorImage = ResourceImage::New( DEFAULT_INDICATOR_IMAGE_PATH );
 205   ImageActor indicator = ImageActor::New( indicatorImage );
 206   indicator.SetNinePatchBorder( DEFAULT_INDICATOR_NINE_PATCH_BORDER );
 207   indicator.SetStyle( ImageActor::STYLE_NINE_PATCH );
 208   indicator.SetParentOrigin( ParentOrigin::TOP_LEFT );
 209   indicator.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 210
 211   SetScrollIndicator(indicator);
 212 }
 213
 214 void ScrollBar::SetScrollIndicator( Actor indicator )
 215 {
 216   // Don't allow empty handle
 217   if( indicator )
 218   {
 219     mIndicator = indicator;
 220
 221     Actor self = Self();
 222     self.Add(mIndicator);
 223
 224     if( !mPanGestureDetector )
 225     {
 226       mPanGestureDetector = PanGestureDetector::New();
 227       mPanGestureDetector.DetectedSignal().Connect(this, &ScrollBar::OnPan);
 228     }
 229
 230     mPanGestureDetector.DetachAll();
 231     mPanGestureDetector.Attach( mIndicator );
 232
 233     unsigned int childCount = mIndicator.GetChildCount();
 234     for ( unsigned int index = 0; index < childCount; index++ )
 235     {
 236       Actor child = mIndicator.GetChildAt( index );
 237       if ( child )
 238       {
 239         mPanGestureDetector.Attach( child );
 240       }
 241     }
 242   }
 243   else
 244   {
 245     DALI_LOG_ERROR("Empty handle of scroll indicator\n");
 246   }
 247 }
 248
 249 Actor ScrollBar::GetScrollIndicator()
 250 {
 251   return mIndicator;
 252 }
 253
 254 void ScrollBar::ApplyConstraints()
 255 {
 256   if( mScrollableObject )
 257   {
 258     if(mIndicatorSizeConstraint)
 259     {
 260       mIndicatorSizeConstraint.Remove();
 261     }
 262
 263     // Set indicator height according to the indicator's height policy
 264     if(mIndicatorHeightPolicy == Toolkit::ScrollBar::Fixed)
 265     {
 266       mIndicator.SetSize(Self().GetCurrentSize().width, mIndicatorFixedHeight);
 267     }
 268     else
 269     {
 270       mIndicatorSizeConstraint = Constraint::New<Vector3>( mIndicator, Actor::Property::SIZE, IndicatorSizeConstraint() );
 271       mIndicatorSizeConstraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 272       mIndicatorSizeConstraint.AddSource( Source( mScrollableObject, mPropertyScrollContentSize ) );
 273       mIndicatorSizeConstraint.Apply();
 274     }
 275
 276     if(mIndicatorPositionConstraint)
 277     {
 278       mIndicatorPositionConstraint.Remove();
 279     }
 280
 281     mIndicatorPositionConstraint = Constraint::New<Vector3>( mIndicator, Actor::Property::POSITION, IndicatorPositionConstraint() );
 282     mIndicatorPositionConstraint.AddSource( LocalSource( Actor::Property::SIZE ) );
 283     mIndicatorPositionConstraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 284     mIndicatorPositionConstraint.AddSource( Source( mScrollableObject, mPropertyScrollPosition ) );
 285     mIndicatorPositionConstraint.AddSource( Source( mScrollableObject, mPropertyMinScrollPosition ) );
 286     mIndicatorPositionConstraint.AddSource( Source( mScrollableObject, mPropertyMaxScrollPosition ) );
 287     mIndicatorPositionConstraint.Apply();
 288   }
 289 }
 290
 291 void ScrollBar::SetScrollPositionIntervals( const Dali::Vector<float>& positions )
 292 {
 293   mScrollPositionIntervals = positions;
 294
 295   if( mScrollableObject )
 296   {
 297     if( mPositionNotification )
 298     {
 299       mScrollableObject.RemovePropertyNotification(mPositionNotification);
 300     }
 301
 302     mPositionNotification = mScrollableObject.AddPropertyNotification( mPropertyScrollPosition, VariableStepCondition(mScrollPositionIntervals) );
 303     mPositionNotification.NotifySignal().Connect( this, &ScrollBar::OnScrollPositionIntervalReached );
 304   }
 305 }
 306
 307 Dali::Vector<float> ScrollBar::GetScrollPositionIntervals() const
 308 {
 309   return mScrollPositionIntervals;
 310 }
 311
 312 void ScrollBar::OnScrollPositionIntervalReached(PropertyNotification& source)
 313 {
 314   // Emit the signal to notify the scroll position crossing
 315   if(mScrollableObject)
 316   {
 317     mScrollPositionIntervalReachedSignal.Emit(mScrollableObject.GetProperty<float>(mPropertyScrollPosition));
 318   }
 319 }
 320
 321 void ScrollBar::ShowIndicator()
 322 {
 323   // Cancel any animation
 324   if(mAnimation)
 325   {
 326     mAnimation.Clear();
 327     mAnimation.Reset();
 328   }
 329
 330   if(mIndicatorShowDuration > 0.0f)
 331   {
 332     mAnimation = Animation::New( mIndicatorShowDuration );
 333     mAnimation.AnimateTo( Property( mIndicator, Actor::Property::COLOR_ALPHA ), 1.0f, AlphaFunction::EASE_IN );
 334     mAnimation.Play();
 335   }
 336   else
 337   {
 338     mIndicator.SetOpacity(1.0f);
 339   }
 340 }
 341
 342 void ScrollBar::HideIndicator()
 343 {
 344   // Cancel any animation
 345   if(mAnimation)
 346   {
 347     mAnimation.Clear();
 348     mAnimation.Reset();
 349   }
 350
 351   if(mIndicatorHideDuration > 0.0f)
 352   {
 353     mAnimation = Animation::New( mIndicatorHideDuration );
 354     mAnimation.AnimateTo( Property( mIndicator, Actor::Property::COLOR_ALPHA ), 0.0f, AlphaFunction::EASE_IN );
 355     mAnimation.Play();
 356   }
 357   else
 358   {
 359     mIndicator.SetOpacity(0.0f);
 360   }
 361 }
 362
 363 bool ScrollBar::OnPanGestureProcessTick()
 364 {
 365   // Update the scroll position property.
 366   if( mScrollableObject )
 367   {
 368     mScrollableObject.SetProperty(mPropertyScrollPosition, mCurrentScrollPosition);
 369   }
 370
 371   return true;
 372 }
 373
 374 void ScrollBar::OnPan( Actor source, const PanGesture& gesture )
 375 {
 376   if(mScrollableObject)
 377   {
 378     Dali::Toolkit::ItemView itemView = Dali::Toolkit::ItemView::DownCast(mScrollableObject);
 379
 380     switch(gesture.state)
 381     {
 382       case Gesture::Started:
 383       {
 384         if( !mPanProcessTimer )
 385         {
 386           // Make sure the pan gesture is only being processed once per frame.
 387           mPanProcessTimer = Timer::New( DEFAULT_PAN_GESTURE_PROCESS_TIME );
 388           mPanProcessTimer.TickSignal().Connect( this, &ScrollBar::OnPanGestureProcessTick );
 389           mPanProcessTimer.Start();
 390         }
 391
 392         ShowIndicator();
 393         mScrollStart = mScrollableObject.GetProperty<float>(mPropertyScrollPosition);
 394         mGestureDisplacement = Vector3::ZERO;
 395         mIsPanning = true;
 396
 397         break;
 398       }
 399       case Gesture::Continuing:
 400       {
 401         Vector3 delta(gesture.displacement.x, gesture.displacement.y, 0.0f);
 402         mGestureDisplacement+=delta;
 403
 404         Vector3 span = Self().GetCurrentSize() - mIndicator.GetCurrentSize();
 405         float minScrollPosition = mScrollableObject.GetProperty<float>(mPropertyMinScrollPosition);
 406         float maxScrollPosition = mScrollableObject.GetProperty<float>(mPropertyMaxScrollPosition);
 407         float domainSize = maxScrollPosition - minScrollPosition;
 408
 409         mCurrentScrollPosition = mScrollStart - mGestureDisplacement.y * domainSize / span.y;
 410         mCurrentScrollPosition = 0.0f - std::min(maxScrollPosition, std::max(-mCurrentScrollPosition, minScrollPosition));
 411
 412         break;
 413       }
 414       default:
 415       {
 416         mIsPanning = false;
 417
 418         if( mPanProcessTimer )
 419         {
 420           // Destroy the timer when pan gesture is finished.
 421           mPanProcessTimer.Stop();
 422           mPanProcessTimer.TickSignal().Disconnect( this, &ScrollBar::OnPanGestureProcessTick );
 423           mPanProcessTimer.Reset();
 424         }
 425
 426         if(itemView)
 427         {
 428           // Refresh the ItemView cache with extra items
 429           GetImpl(itemView).DoRefresh(mCurrentScrollPosition, true);
 430         }
 431
 432         mPanFinishedSignal.Emit();
 433
 434         break;
 435       }
 436     }
 437
 438     if(itemView)
 439     {
 440       // Disable automatic refresh in ItemView during fast scrolling
 441       GetImpl(itemView).SetRefreshEnabled(true);//!mIsPanning);
 442     }
 443   }
 444 }
 445
 446 void ScrollBar::OnSizeSet( const Vector3& size )
 447 {
 448   if(mIndicatorHeightPolicy == Toolkit::ScrollBar::Fixed)
 449   {
 450     mIndicator.SetSize(size.width, mIndicatorFixedHeight);
 451   }
 452 }
 453
 454 void ScrollBar::SetScrollDirection( Toolkit::ScrollBar::Direction direction )
 455 {
 456   mDirection = direction;
 457 }
 458
 459 Toolkit::ScrollBar::Direction ScrollBar::GetScrollDirection() const
 460 {
 461   return mDirection;
 462 }
 463
 464 void ScrollBar::SetIndicatorHeightPolicy( Toolkit::ScrollBar::IndicatorHeightPolicy policy )
 465 {
 466   mIndicatorHeightPolicy = policy;
 467   ApplyConstraints();
 468 }
 469
 470 Toolkit::ScrollBar::IndicatorHeightPolicy ScrollBar::GetIndicatorHeightPolicy() const
 471 {
 472   return mIndicatorHeightPolicy;
 473 }
 474
 475 void ScrollBar::SetIndicatorFixedHeight( float height )
 476 {
 477   mIndicatorFixedHeight = height;
 478
 479   if(mIndicatorHeightPolicy == Toolkit::ScrollBar::Fixed)
 480   {
 481     mIndicator.SetSize(Self().GetCurrentSize().width, mIndicatorFixedHeight);
 482   }
 483 }
 484
 485 float ScrollBar::GetIndicatorFixedHeight() const
 486 {
 487   return mIndicatorFixedHeight;
 488 }
 489
 490 void ScrollBar::SetIndicatorShowDuration( float durationSeconds )
 491 {
 492   mIndicatorShowDuration = durationSeconds;
 493 }
 494
 495 float ScrollBar::GetIndicatorShowDuration() const
 496 {
 497   return mIndicatorShowDuration;
 498 }
 499
 500 void ScrollBar::SetIndicatorHideDuration( float durationSeconds )
 501 {
 502   mIndicatorHideDuration = durationSeconds;
 503 }
 504
 505 float ScrollBar::GetIndicatorHideDuration() const
 506 {
 507   return mIndicatorHideDuration;
 508 }
 509
 510 void ScrollBar::OnScrollDirectionPropertySet( Property::Value propertyValue )
 511 {
 512   std::string directionName( propertyValue.Get<std::string>() );
 513   if(directionName == "Vertical")
 514   {
 515     SetScrollDirection(Toolkit::ScrollBar::Vertical);
 516   }
 517   else if(directionName == "Horizontal")
 518   {
 519     SetScrollDirection(Toolkit::ScrollBar::Horizontal);
 520   }
 521   else
 522   {
 523     DALI_ASSERT_ALWAYS( !"ScrollBar::OnScrollDirectionPropertySet(). Invalid Property value." );
 524   }
 525 }
 526
 527 void ScrollBar::OnIndicatorHeightPolicyPropertySet( Property::Value propertyValue )
 528 {
 529   std::string policyName( propertyValue.Get<std::string>() );
 530   if(policyName == "Variable")
 531   {
 532     SetIndicatorHeightPolicy(Toolkit::ScrollBar::Variable);
 533   }
 534   else if(policyName == "Fixed")
 535   {
 536     SetIndicatorHeightPolicy(Toolkit::ScrollBar::Fixed);
 537   }
 538   else
 539   {
 540     DALI_ASSERT_ALWAYS( !"ScrollBar::OnIndicatorHeightPolicyPropertySet(). Invalid Property value." );
 541   }
 542 }
 543
 544 bool ScrollBar::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 545 {
 546   Dali::BaseHandle handle( object );
 547
 548   bool connected( true );
 549   Toolkit::ScrollBar scrollBar = Toolkit::ScrollBar::DownCast( handle );
 550
 551   if( 0 == strcmp( signalName.c_str(), PAN_FINISHED_SIGNAL ) )
 552   {
 553     scrollBar.PanFinishedSignal().Connect( tracker, functor );
 554   }
 555   else if( 0 == strcmp( signalName.c_str(), SCROLL_POSITION_INTERVAL_REACHED_SIGNAL ) )
 556   {
 557     scrollBar.ScrollPositionIntervalReachedSignal().Connect( tracker, functor );
 558   }
 559   else
 560   {
 561     // signalName does not match any signal
 562     connected = false;
 563   }
 564
 565   return connected;
 566 }
 567
 568 void ScrollBar::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
 569 {
 570   Toolkit::ScrollBar scrollBar = Toolkit::ScrollBar::DownCast( Dali::BaseHandle( object ) );
 571
 572   if( scrollBar )
 573   {
 574     ScrollBar& scrollBarImpl( GetImpl( scrollBar ) );
 575     switch( index )
 576     {
 577       case Toolkit::ScrollBar::Property::SCROLL_DIRECTION:
 578       {
 579         scrollBarImpl.OnScrollDirectionPropertySet( value );
 580         break;
 581       }
 582       case Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY:
 583       {
 584         scrollBarImpl.OnIndicatorHeightPolicyPropertySet( value );
 585         break;
 586       }
 587       case Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT:
 588       {
 589         scrollBarImpl.SetIndicatorFixedHeight(value.Get<float>());
 590         break;
 591       }
 592       case Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION:
 593       {
 594         scrollBarImpl.SetIndicatorShowDuration(value.Get<float>());
 595         break;
 596       }
 597       case Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION:
 598       {
 599         scrollBarImpl.SetIndicatorHideDuration(value.Get<float>());
 600         break;
 601       }
 602       case Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS:
 603       {
 604         Property::Array* array = value.GetArray();
 605         if( array )
 606         {
 607           Dali::Vector<float> positions;
 608           size_t positionCount = array->Count();
 609           positions.Resize( positionCount );
 610           for( size_t i = 0; i != positionCount; ++i )
 611           {
 612             array->GetElementAt( i ).Get( positions[i] );
 613           }
 614
 615           scrollBarImpl.SetScrollPositionIntervals(positions);
 616         }
 617         break;
 618       }
 619     }
 620   }
 621 }
 622
 623 Property::Value ScrollBar::GetProperty( BaseObject* object, Property::Index index )
 624 {
 625   Property::Value value;
 626
 627   Toolkit::ScrollBar scrollBar = Toolkit::ScrollBar::DownCast( Dali::BaseHandle( object ) );
 628
 629   if( scrollBar )
 630   {
 631     ScrollBar& scrollBarImpl( GetImpl( scrollBar ) );
 632     switch( index )
 633     {
 634       case Toolkit::ScrollBar::Property::SCROLL_DIRECTION:
 635       {
 636         value = SCROLL_DIRECTION_NAME[ scrollBarImpl.GetScrollDirection() ];
 637         break;
 638       }
 639       case Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY:
 640       {
 641         value = INDICATOR_HEIGHT_POLICY_NAME[ scrollBarImpl.GetIndicatorHeightPolicy() ];
 642         break;
 643       }
 644       case Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT:
 645       {
 646         value = scrollBarImpl.GetIndicatorFixedHeight();
 647         break;
 648       }
 649       case Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION:
 650       {
 651         value = scrollBarImpl.GetIndicatorShowDuration();
 652         break;
 653       }
 654       case Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION:
 655       {
 656         value = scrollBarImpl.GetIndicatorHideDuration();
 657         break;
 658       }
 659       case Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS:
 660       {
 661         Property::Value value( Property::ARRAY );
 662         Property::Array* array = value.GetArray();
 663         Dali::Vector<float> positions = scrollBarImpl.GetScrollPositionIntervals();
 664         size_t positionCount( array->Count() );
 665         for( size_t i( 0 ); i != positionCount; ++i )
 666         {
 667           array->PushBack( positions[i] );
 668         }
 669         break;
 670       }
 671     }
 672   }
 673   return value;
 674 }
 675
 676 Toolkit::ScrollBar ScrollBar::New(Toolkit::ScrollBar::Direction direction)
 677 {
 678   // Create the implementation, temporarily owned by this handle on stack
 679   IntrusivePtr< ScrollBar > impl = new ScrollBar(direction);
 680
 681   // Pass ownership to CustomActor handle
 682   Toolkit::ScrollBar handle( *impl );
 683
 684   // Second-phase init of the implementation
 685   // This can only be done after the CustomActor connection has been made...
 686   impl->Initialize();
 687
 688   return handle;
 689 }
 690
 691 } // namespace Internal
 692
 693 } // namespace Toolkit
 694
 695 } // namespace Dali