2 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include <dali-toolkit/internal/controls/slider/slider-impl.h>
23 #include <dali/public-api/events/touch-event.h>
24 #include <dali/public-api/object/type-registry.h>
25 #include <dali/public-api/object/type-registry-helper.h>
26 #include <dali/public-api/images/resource-image.h>
29 #include <dali-toolkit/public-api/controls/control-impl.h>
42 namespace // Unnamed namespace
47 return Dali::Toolkit::Slider::New();
50 // Setup properties, signals and actions using the type-registry.
51 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create )
53 DALI_PROPERTY_REGISTRATION( Slider, "lower-bound", FLOAT, LOWER_BOUND )
54 DALI_PROPERTY_REGISTRATION( Slider, "upper-bound", FLOAT, UPPER_BOUND )
55 DALI_PROPERTY_REGISTRATION( Slider, "value", FLOAT, VALUE )
56 DALI_PROPERTY_REGISTRATION( Slider, "hit-region", VECTOR2, HIT_REGION )
57 DALI_PROPERTY_REGISTRATION( Slider, "backing-region", VECTOR2, BACKING_REGION )
58 DALI_PROPERTY_REGISTRATION( Slider, "handle-region", VECTOR2, HANDLE_REGION )
59 DALI_PROPERTY_REGISTRATION( Slider, "backing-image-name", STRING, BACKING_IMAGE_NAME )
60 DALI_PROPERTY_REGISTRATION( Slider, "handle-image-name", STRING, HANDLE_IMAGE_NAME )
61 DALI_PROPERTY_REGISTRATION( Slider, "progress-image-name", STRING, PROGRESS_IMAGE_NAME )
62 DALI_PROPERTY_REGISTRATION( Slider, "popup-image-name", STRING, POPUP_IMAGE_NAME )
63 DALI_PROPERTY_REGISTRATION( Slider, "popup-arrow-image-name", STRING, POPUP_ARROW_IMAGE_NAME )
64 DALI_PROPERTY_REGISTRATION( Slider, "disable-color", VECTOR4, DISABLE_COLOR )
65 DALI_PROPERTY_REGISTRATION( Slider, "popup-text-color", VECTOR4, POPUP_TEXT_COLOR )
66 DALI_PROPERTY_REGISTRATION( Slider, "value-precision", INTEGER, VALUE_PRECISION )
67 DALI_PROPERTY_REGISTRATION( Slider, "show-popup", BOOLEAN, SHOW_POPUP )
68 DALI_PROPERTY_REGISTRATION( Slider, "show-value", BOOLEAN, SHOW_VALUE )
69 DALI_PROPERTY_REGISTRATION( Slider, "enabled", BOOLEAN, ENABLED )
70 DALI_PROPERTY_REGISTRATION( Slider, "marks", ARRAY, MARKS )
71 DALI_PROPERTY_REGISTRATION( Slider, "snap-to-marks", BOOLEAN, SNAP_TO_MARKS )
72 DALI_PROPERTY_REGISTRATION( Slider, "mark-tolerance", FLOAT, MARK_TOLERANCE )
74 DALI_SIGNAL_REGISTRATION( Slider, "value-changed", SIGNAL_VALUE_CHANGED )
75 DALI_SIGNAL_REGISTRATION( Slider, "mark", SIGNAL_MARK )
77 DALI_TYPE_REGISTRATION_END()
79 const float BACKING_Z = -0.1f;
80 const float PROGRESS_Z = 0.1f;
81 const float HANDLE_Z = 1.0f;
82 const float VALUE_TEXT_INCREMENT = 0.01f;
83 const float HANDLE_VALUE_DISPLAY_TEXT_Z = HANDLE_Z + VALUE_TEXT_INCREMENT;
84 const float VALUE_DISPLAY_TEXT_Z = VALUE_TEXT_INCREMENT + VALUE_TEXT_INCREMENT; // Put above HANDLE_VALUE_DISPLAY_TEXT_Z (parented to handle)
86 const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
88 const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec
89 const int VALUE_VIEW_SHOW_DURATION_LONG = 2000; // millisec
91 const float VALUE_VERTICAL_OFFSET = 48.0f;
93 const float DEFAULT_WIDTH = 0.0f;
94 const float DEFAULT_HEIGHT = 27.0f;
95 const float DEFAULT_HIT_HEIGHT = 72.0f;
96 const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
98 const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.9.png";
99 const char* SKINNED_HANDLE_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-handle.png";;
100 const char* SKINNED_PROGRESS_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-progress.9.png";
101 const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.9.png";
102 const char* SKINNED_POPUP_ARROW_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup-arrow.png";
104 const Vector2 DEFAULT_HIT_REGION( DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT );
105 const Vector2 DEFAULT_BACKING_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT );
106 const Vector2 DEFAULT_HANDLE_REGION( DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT );
108 const Vector4 DEFAULT_DISABLE_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
109 const Vector4 DEFAULT_POPUP_TEXT_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
111 const float VALUE_POPUP_MARGIN = 10.0f;
112 const float VALUE_POPUP_HEIGHT = 81.0f;
113 const float VALUE_POPUP_MIN_WIDTH = 54.0f;
114 const Vector2 VALUE_POPUP_ARROW_SIZE( 18.0f, 18.0f );
116 const float DEFAULT_LOWER_BOUND = 0.0f;
117 const float DEFAULT_UPPER_BOUND = 1.0f;
118 const float DEFAULT_VALUE = 0.0f;
119 const int DEFAULT_VALUE_PRECISION = 0;
120 const bool DEFAULT_SHOW_POPUP = false;
121 const bool DEFAULT_SHOW_VALUE = true;
122 const bool DEFAULT_ENABLED = true;
123 const bool DEFAULT_SNAP_TO_MARKS = false;
125 } // Unnamed namespace
127 ///////////////////////////////////////////////////////////////////////////////////////////////////
129 ///////////////////////////////////////////////////////////////////////////////////////////////////
131 Dali::Toolkit::Slider Slider::New()
133 // Create the implementation
134 SliderPtr slider( new Slider() );
136 // Pass ownership to CustomActor via derived handle
137 Dali::Toolkit::Slider handle( *slider );
139 // Second-phase init of the implementation
140 // This can only be done after the CustomActor connection has been made...
141 slider->Initialize();
147 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
149 mDisableColor( 0.0f, 0.0f, 0.0f, 0.0f ),
150 mPopupTextColor( 0.0f, 0.0f, 0.0f, 0.0f ),
151 mHitRegion( 0.0f, 0.0f ),
152 mBackingRegion( 0.0f, 0.0f ),
153 mHandleRegionSize( 0.0f, 0.0f ),
157 mMarkTolerance( 0.0f ),
158 mValuePrecision( 0 ),
161 mSnapToMarks( false )
169 void Slider::OnInitialize()
177 SetHitRegion( DEFAULT_HIT_REGION );
178 SetBackingRegion( DEFAULT_BACKING_REGION );
179 SetHandleRegion( DEFAULT_HANDLE_REGION );
181 SetBackingImageName( SKINNED_BACKING_IMAGE_NAME );
182 SetHandleImageName( SKINNED_HANDLE_IMAGE_NAME );
183 SetProgressImageName( SKINNED_PROGRESS_IMAGE_NAME );
184 SetPopupImageName( SKINNED_POPUP_IMAGE_NAME );
185 SetPopupArrowImageName( SKINNED_POPUP_ARROW_IMAGE_NAME );
187 SetPopupTextColor( DEFAULT_POPUP_TEXT_COLOR );
189 SetShowPopup( DEFAULT_SHOW_POPUP );
190 SetShowValue( DEFAULT_SHOW_VALUE );
192 SetEnabled( DEFAULT_ENABLED );
193 SetDisableColor( DEFAULT_DISABLE_COLOR );
195 SetSnapToMarks( DEFAULT_SNAP_TO_MARKS );
196 SetMarkTolerance( MARK_SNAP_TOLERANCE );
198 SetLowerBound( DEFAULT_LOWER_BOUND );
199 SetUpperBound( DEFAULT_UPPER_BOUND );
201 SetValuePrecision( DEFAULT_VALUE_PRECISION );
202 mValue = DEFAULT_VALUE;
203 DisplayValue( mValue, false ); // Run this last to display the correct value
205 // Size the Slider actor to a default
206 self.SetSize( DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y );
209 void Slider::OnControlSizeSet( const Vector3& size )
211 // Factor in handle overshoot into size of backing
212 SetHitRegion( Vector2( size.x, GetHitRegion().y ) );
213 SetBackingRegion( Vector2( size.x - GetHandleRegion().x, GetBackingRegion().y ) );
216 bool Slider::OnTouchEvent(Actor actor, const TouchEvent& event)
218 if( mState != DISABLED )
220 TouchPoint::State touchState = event.GetPoint(0).state;
222 if( touchState == TouchPoint::Down )
226 float percentage = MapPercentage( event.GetPoint(0).local );
227 float value = MapBounds( ( GetSnapToMarks() ) ? SnapToMark( percentage ) : MarkFilter( percentage ), GetLowerBound(), GetUpperBound() );
229 DisplayPopup( value );
231 else if( touchState == TouchPoint::Up)
233 if( mState == PRESSED )
236 mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
244 void Slider::OnPan( Actor actor, const PanGesture& gesture )
246 // gesture.position is in local actor coordinates
247 if( mState != DISABLED )
249 switch( gesture.state )
251 case Gesture::Continuing:
253 if( mState == PRESSED )
255 float value = MapBounds( MarkFilter ( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
257 DisplayPopup( value );
261 case Gesture::Finished:
263 if( mState == PRESSED )
265 if( GetSnapToMarks() )
267 float value = MapBounds( SnapToMark( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
269 DisplayPopup( value );
271 mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
285 float Slider::HitSpaceToDomain( float x )
287 float halfRegionWidth = GetHitRegion().x * 0.5f;
288 float halfDomainWidth = ( mDomain.to.x - mDomain.from.x ) * 0.5f;
289 float endDiff = halfRegionWidth - halfDomainWidth;
294 float Slider::MapPercentage( const Vector2& point )
296 return Clamp( ( HitSpaceToDomain( point.x ) - mDomain.from.x ) / ( mDomain.to.x - mDomain.from.x ), 0.0f, 1.0f );
299 float Slider::MapValuePercentage( float value )
301 return ( value - GetLowerBound() ) / ( GetUpperBound() - GetLowerBound() );
304 float Slider::MapBounds( float percent, float lowerBound, float upperBound )
306 return lowerBound + percent * ( upperBound - lowerBound );
309 Slider::Domain Slider::CalcDomain( const Vector2& currentSize )
311 return Domain( Vector2( 0.0f, 0.0f ), currentSize );
314 void Slider::DisplayValue( float value, bool raiseSignals )
316 float clampledValue = Clamp( value, GetLowerBound(), GetUpperBound() );
318 float percent = MapValuePercentage( clampledValue );
320 float x = mDomain.from.x + percent * ( mDomain.to.x - mDomain.from.x );
322 mHandle.SetPosition( x, 0.0f, HANDLE_Z );
327 if( clampledValue > 0.0f )
329 mProgress.SetVisible( true ); // Deliberately set this in case multiple SetValues are fired at once
330 mProgress.SetSize( x, GetBackingRegion().y );
334 mProgress.SetVisible( false );
341 Toolkit::Slider self = Toolkit::Slider::DownCast( Self() );
342 mValueChangedSignal.Emit( self, clampledValue );
345 if( MarkReached( percent, markIndex ) )
347 mMarkSignal.Emit( self, markIndex );
352 void Slider::SetMarks( const MarkList& marks )
355 for( MarkList::const_iterator it = marks.begin(), itEnd = marks.end(); it != itEnd; ++it )
357 const Property::Value& propertyValue = *it;
358 propertyValue.Get( value );
360 mMarks.push_back( value );
364 const Slider::MarkList& Slider::GetMarks() const
369 void Slider::SetSnapToMarks( bool snap )
374 bool Slider::GetSnapToMarks() const
379 Actor Slider::CreateHitRegion()
381 Actor hitRegion = Actor::New();
382 hitRegion.SetParentOrigin( ParentOrigin::CENTER );
383 hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
384 hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
389 ImageActor Slider::CreateBacking()
391 ImageActor backing = ImageActor::New();
392 backing.SetParentOrigin( ParentOrigin::CENTER );
393 backing.SetAnchorPoint( AnchorPoint::CENTER );
394 backing.SetZ( BACKING_Z );
399 void Slider::SetBackingImageName( const std::string& imageName )
401 if( mBacking && ( imageName.size() > 0 ) )
403 Image image = ResourceImage::New( imageName );
404 mBacking.SetImage( image );
408 std::string Slider::GetBackingImageName()
412 return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
415 return std::string( "" );
418 ImageActor Slider::CreateProgress()
420 ImageActor progress = ImageActor::New();
421 progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
422 progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
423 progress.SetZ( PROGRESS_Z );
428 void Slider::SetProgressImageName( const std::string& imageName )
430 if( mProgress && ( imageName.size() > 0 ) )
432 Image image = ResourceImage::New( imageName );
433 mProgress.SetImage( image );
437 std::string Slider::GetProgressImageName()
441 return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
444 return std::string( "" );
447 void Slider::SetPopupImageName( const std::string& imageName )
449 mPopupImageName = imageName;
452 std::string Slider::GetPopupImageName()
454 return mPopupImageName;
457 void Slider::CreatePopupImage( const std::string& imageName )
459 if( mPopup && ( imageName.size() > 0 ) )
461 Image image = ResourceImage::New( imageName );
462 mPopup.SetImage( image );
466 void Slider::SetPopupArrowImageName( const std::string& imageName )
468 mPopupArrowImageName = imageName;
471 std::string Slider::GetPopupArrowImageName()
473 return mPopupArrowImageName;
476 void Slider::CreatePopupArrowImage( const std::string& imageName )
478 if( mPopupArrow && ( imageName.size() > 0 ) )
480 Image image = ResourceImage::New( imageName );
481 mPopupArrow.SetImage( image );
485 void Slider::ResizeProgressRegion( const Vector2& region )
489 mProgress.SetSize( region );
493 ImageActor Slider::CreateHandle()
495 ImageActor handle = ImageActor::New();
496 handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
497 handle.SetAnchorPoint( AnchorPoint::CENTER );
498 handle.SetZ( HANDLE_Z );
503 ImageActor Slider::CreatePopupArrow()
505 ImageActor arrow = ImageActor::New();
506 arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
507 arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
508 arrow.SetZ( HANDLE_Z );
513 //Toolkit::TextView Slider::CreatePopupText()
517 ImageActor Slider::CreatePopup()
519 ImageActor popup = ImageActor::New();
520 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
521 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
526 void Slider::SetHandleImageName( const std::string& imageName )
528 if( mHandle && ( imageName.size() > 0 ) )
530 Image image = ResourceImage::New( imageName );
531 mHandle.SetImage( image );
535 std::string Slider::GetHandleImageName()
539 return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
542 return std::string( "" );
545 void Slider::ResizeHandleRegion( const Vector2& region )
549 mHandle.SetSize( region );
553 void Slider::CreateHandleValueDisplay()
557 void Slider::DestroyHandleValueDisplay()
561 void Slider::SetPopupTextColor( const Vector4& color )
563 mPopupTextColor = color;
566 Actor Slider::CreateValueDisplay()
568 Actor popup = Actor::New();
569 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
570 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
572 mPopupArrow = CreatePopupArrow();
573 popup.Add( mPopupArrow );
575 mPopup = CreatePopup();
576 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
577 mPopupArrow.Add( mPopup );
582 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
584 return mValueChangedSignal;
587 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
589 return mSlidingFinishedSignal;
592 Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
597 void Slider::UpdateSkin()
603 mBacking.SetColor( Color::WHITE );
604 mHandle.SetColor( Color::WHITE );
605 mProgress.SetColor( Color::WHITE );
610 Vector4 disableColor = GetDisableColor();
611 mBacking.SetColor( disableColor );
612 mHandle.SetColor( disableColor );
613 mProgress.SetColor( disableColor );
627 void Slider::CreateChildren()
632 mHitArea = CreateHitRegion();
633 mPanDetector = PanGestureDetector::New();
634 mPanDetector.Attach( mHitArea );
635 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
636 self.Add( mHitArea );
639 mBacking = CreateBacking();
640 self.Add( mBacking );
643 mProgress = CreateProgress();
644 mBacking.Add( mProgress );
647 mHandle = CreateHandle();
648 mBacking.Add( mHandle );
651 void Slider::SetHitRegion( const Vector2& size )
657 mHitArea.SetSize( mHitRegion );
661 const Vector2& Slider::GetHitRegion() const
666 void Slider::AddPopup()
670 mValueDisplay = CreateValueDisplay();
671 mValueDisplay.SetVisible( false );
672 mHandle.Add( mValueDisplay );
674 CreatePopupImage( GetPopupImageName() );
675 CreatePopupArrowImage( GetPopupArrowImageName() );
677 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
678 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
682 void Slider::RemovePopup()
689 mPopupArrow.Unparent();
692 mValueDisplay.Unparent();
693 mValueDisplay.Reset();
695 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
701 float Slider::MarkFilter( float value )
703 const float MARK_TOLERANCE = GetMarkTolerance();
706 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
708 const Property::Value& propertyValue = *it;
709 propertyValue.Get( mark );
710 mark = MapValuePercentage( mark );
712 // If close to a mark, return the mark
713 if( fabsf( mark - value ) < MARK_TOLERANCE )
722 float Slider::SnapToMark( float value )
724 float closestMark = value;
725 float closestDist = std::numeric_limits<float>::max();
728 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
730 const Property::Value& propertyValue = *it;
731 propertyValue.Get( mark );
732 mark = MapValuePercentage( mark );
734 float dist = fabsf( mark - value );
735 if( dist < closestDist )
745 bool Slider::MarkReached( float value, int& outIndex )
747 const float MARK_TOLERANCE = GetMarkTolerance();
751 tail = mMarks.size() - 1;
755 while( head <= tail )
757 current = head + ( tail - head ) / 2;
759 const Property::Value& propertyValue = mMarks[ current ];
760 propertyValue.Get( mark );
761 mark = MapValuePercentage( mark );
763 if( fabsf( mark - value ) < MARK_TOLERANCE )
782 bool Slider::HideValueView()
786 mValueDisplay.SetVisible( false );
792 void Slider::SetLowerBound( float bound )
795 DisplayValue( GetValue(), false );
798 float Slider::GetLowerBound() const
803 void Slider::SetUpperBound( float bound )
806 DisplayValue( GetValue(), false );
809 float Slider::GetUpperBound() const
814 void Slider::SetValue( float value )
817 DisplayValue( mValue, true );
820 float Slider::GetValue() const
825 void Slider::SetBackingRegion( const Vector2& region )
827 mBackingRegion = region;
831 mBacking.SetSize( mBackingRegion );
834 ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
836 mDomain = CalcDomain( mBackingRegion );
838 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
841 const Vector2& Slider::GetBackingRegion() const
843 return mBackingRegion;
846 void Slider::SetHandleRegion( const Vector2& region )
848 mHandleRegionSize = region;
850 ResizeHandleRegion( mHandleRegionSize );
852 Vector2 hitRegion = GetHitRegion();
853 hitRegion.x += mHandleRegionSize.x;
854 SetHitRegion( hitRegion );
857 const Vector2& Slider::GetHandleRegion() const
859 return mHandleRegionSize;
862 void Slider::SetDisableColor( const Vector4& color )
864 mDisableColor = color;
869 Vector4 Slider::GetDisableColor() const
871 return mDisableColor;
874 Vector4 Slider::GetPopupTextColor() const
876 return mPopupTextColor;
879 void Slider::SetValuePrecision( int precision )
881 mValuePrecision = precision;
884 int Slider::GetValuePrecision() const
886 return mValuePrecision;
889 void Slider::SetShowPopup( bool showPopup )
891 mShowPopup = showPopup;
904 bool Slider::GetShowPopup() const
909 void Slider::SetShowValue( bool showValue )
911 mShowValue = showValue;
915 CreateHandleValueDisplay();
919 DestroyHandleValueDisplay();
923 bool Slider::GetShowValue() const
928 void Slider::SetEnabled( bool enabled )
942 bool Slider::IsEnabled() const
944 return mState != DISABLED;
947 void Slider::SetMarkTolerance( float tolerance )
949 mMarkTolerance = tolerance;
952 float Slider::GetMarkTolerance() const
954 return mMarkTolerance;
957 // Static class method to support script connecting signals
958 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
960 Dali::BaseHandle handle( object );
962 bool connected = true;
963 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
965 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
967 slider.ValueChangedSignal().Connect( tracker, functor );
969 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
971 slider.MarkSignal().Connect( tracker, functor );
975 // signalName does not match any signal
982 void Slider::DisplayPopup( float value )
986 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
988 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
992 Slider& sliderImpl( GetImpl( slider ) );
994 switch ( propertyIndex )
996 case Toolkit::Slider::Property::LOWER_BOUND:
998 sliderImpl.SetLowerBound( value.Get< float >() );
1002 case Toolkit::Slider::Property::UPPER_BOUND:
1004 sliderImpl.SetUpperBound( value.Get< float >() );
1008 case Toolkit::Slider::Property::VALUE:
1010 sliderImpl.SetValue( value.Get< float >() );
1014 case Toolkit::Slider::Property::HIT_REGION:
1016 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1020 case Toolkit::Slider::Property::BACKING_REGION:
1022 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1026 case Toolkit::Slider::Property::HANDLE_REGION:
1028 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1032 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1034 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1038 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1040 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1044 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1046 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1050 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1052 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1056 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1058 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1062 case Toolkit::Slider::Property::DISABLE_COLOR:
1064 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1068 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1070 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1074 case Toolkit::Slider::Property::VALUE_PRECISION:
1076 sliderImpl.SetValuePrecision( value.Get< int >() );
1080 case Toolkit::Slider::Property::SHOW_POPUP:
1082 sliderImpl.SetShowPopup( value.Get< bool >() );
1086 case Toolkit::Slider::Property::SHOW_VALUE:
1088 sliderImpl.SetShowValue( value.Get< bool >() );
1092 case Toolkit::Slider::Property::ENABLED:
1094 sliderImpl.SetEnabled( value.Get< bool >() );
1098 case Toolkit::Slider::Property::MARKS:
1100 sliderImpl.SetMarks( value.Get< Property::Array >() );
1104 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1106 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1110 case Toolkit::Slider::Property::MARK_TOLERANCE:
1112 sliderImpl.SetMarkTolerance( value.Get< float >() );
1119 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1121 Property::Value value;
1123 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1127 Slider& sliderImpl( GetImpl( slider ) );
1129 switch ( propertyIndex )
1131 case Toolkit::Slider::Property::LOWER_BOUND:
1133 value = sliderImpl.GetLowerBound();
1137 case Toolkit::Slider::Property::UPPER_BOUND:
1139 value = sliderImpl.GetUpperBound();
1143 case Toolkit::Slider::Property::VALUE:
1145 value = sliderImpl.GetValue();
1149 case Toolkit::Slider::Property::HIT_REGION:
1151 value = sliderImpl.GetHitRegion();
1155 case Toolkit::Slider::Property::BACKING_REGION:
1157 value = sliderImpl.GetBackingRegion();
1161 case Toolkit::Slider::Property::HANDLE_REGION:
1163 value = sliderImpl.GetHandleRegion();
1167 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1169 value = sliderImpl.GetBackingImageName();
1173 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1175 value = sliderImpl.GetHandleImageName();
1179 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1181 value = sliderImpl.GetProgressImageName();
1185 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1187 value = sliderImpl.GetPopupImageName();
1191 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1193 value = sliderImpl.GetPopupArrowImageName();
1197 case Toolkit::Slider::Property::DISABLE_COLOR:
1199 value = sliderImpl.GetDisableColor();
1203 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1205 value = sliderImpl.GetPopupTextColor();
1209 case Toolkit::Slider::Property::VALUE_PRECISION:
1211 value = sliderImpl.GetValuePrecision();
1215 case Toolkit::Slider::Property::SHOW_POPUP:
1217 value = sliderImpl.GetShowPopup();
1221 case Toolkit::Slider::Property::SHOW_VALUE:
1223 value = sliderImpl.GetShowValue();
1227 case Toolkit::Slider::Property::ENABLED:
1229 value = sliderImpl.IsEnabled();
1233 case Toolkit::Slider::Property::MARKS:
1235 // TODO: Need to be able to return a PropertyArray
1236 // value = sliderImpl.GetMarks();
1240 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1242 value = sliderImpl.GetSnapToMarks();
1246 case Toolkit::Slider::Property::MARK_TOLERANCE:
1248 value = sliderImpl.GetMarkTolerance();
1257 } // namespace Internal
1259 } // namespace Toolkit