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 );
351 if( mHandleValueTextLabel )
353 std::stringstream ss;
354 ss.precision( GetValuePrecision() );
355 ss << std::fixed << clampledValue;
357 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
361 void Slider::SetMarks( const MarkList& marks )
364 for( MarkList::const_iterator it = marks.begin(), itEnd = marks.end(); it != itEnd; ++it )
366 const Property::Value& propertyValue = *it;
367 propertyValue.Get( value );
369 mMarks.push_back( value );
373 const Slider::MarkList& Slider::GetMarks() const
378 void Slider::SetSnapToMarks( bool snap )
383 bool Slider::GetSnapToMarks() const
388 Actor Slider::CreateHitRegion()
390 Actor hitRegion = Actor::New();
391 hitRegion.SetParentOrigin( ParentOrigin::CENTER );
392 hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
393 hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
398 ImageActor Slider::CreateBacking()
400 ImageActor backing = ImageActor::New();
401 backing.SetRelayoutEnabled( false );
402 backing.SetParentOrigin( ParentOrigin::CENTER );
403 backing.SetAnchorPoint( AnchorPoint::CENTER );
404 backing.SetZ( BACKING_Z );
409 void Slider::SetBackingImageName( const std::string& imageName )
411 if( mBacking && ( imageName.size() > 0 ) )
413 Image image = ResourceImage::New( imageName );
414 mBacking.SetImage( image );
418 std::string Slider::GetBackingImageName()
422 return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
425 return std::string( "" );
428 ImageActor Slider::CreateProgress()
430 ImageActor progress = ImageActor::New();
431 progress.SetRelayoutEnabled( false );
432 progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
433 progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
434 progress.SetZ( PROGRESS_Z );
439 void Slider::SetProgressImageName( const std::string& imageName )
441 if( mProgress && ( imageName.size() > 0 ) )
443 Image image = ResourceImage::New( imageName );
444 mProgress.SetImage( image );
448 std::string Slider::GetProgressImageName()
452 return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
455 return std::string( "" );
458 void Slider::SetPopupImageName( const std::string& imageName )
460 mPopupImageName = imageName;
463 std::string Slider::GetPopupImageName()
465 return mPopupImageName;
468 void Slider::CreatePopupImage( const std::string& imageName )
470 if( mPopup && ( imageName.size() > 0 ) )
472 Image image = ResourceImage::New( imageName );
473 mPopup.SetImage( image );
477 void Slider::SetPopupArrowImageName( const std::string& imageName )
479 mPopupArrowImageName = imageName;
482 std::string Slider::GetPopupArrowImageName()
484 return mPopupArrowImageName;
487 void Slider::CreatePopupArrowImage( const std::string& imageName )
489 if( mPopupArrow && ( imageName.size() > 0 ) )
491 Image image = ResourceImage::New( imageName );
492 mPopupArrow.SetImage( image );
496 void Slider::ResizeProgressRegion( const Vector2& region )
500 mProgress.SetSize( region );
504 ImageActor Slider::CreateHandle()
506 ImageActor handle = ImageActor::New();
507 handle.SetRelayoutEnabled( false );
508 handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
509 handle.SetAnchorPoint( AnchorPoint::CENTER );
510 handle.SetZ( HANDLE_Z );
515 ImageActor Slider::CreatePopupArrow()
517 ImageActor arrow = ImageActor::New();
518 arrow.SetRelayoutEnabled( false );
519 arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
520 arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
521 arrow.SetZ( HANDLE_Z );
526 Toolkit::TextLabel Slider::CreatePopupText()
528 Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
529 textLabel.SetParentOrigin( ParentOrigin::CENTER );
530 textLabel.SetAnchorPoint( AnchorPoint::CENTER );
531 textLabel.SetZ( VALUE_DISPLAY_TEXT_Z );
535 ImageActor Slider::CreatePopup()
537 ImageActor popup = ImageActor::New();
538 popup.SetRelayoutEnabled( false );
539 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
540 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
545 void Slider::SetHandleImageName( const std::string& imageName )
547 if( mHandle && ( imageName.size() > 0 ) )
549 Image image = ResourceImage::New( imageName );
550 mHandle.SetImage( image );
554 std::string Slider::GetHandleImageName()
558 return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
561 return std::string( "" );
564 void Slider::ResizeHandleRegion( const Vector2& region )
568 mHandle.SetSize( region );
572 void Slider::CreateHandleValueDisplay()
574 if( mHandle && !mHandleValueTextLabel )
576 mHandleValueTextLabel = Toolkit::TextLabel::New();
577 mHandleValueTextLabel.SetParentOrigin( ParentOrigin::CENTER );
578 mHandleValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER );
579 mHandleValueTextLabel.SetDrawMode( DrawMode::OVERLAY );
580 mHandle.Add( mHandleValueTextLabel );
584 void Slider::DestroyHandleValueDisplay()
586 UnparentAndReset(mHandleValueTextLabel);
589 void Slider::SetPopupTextColor( const Vector4& color )
591 mPopupTextColor = color;
594 Actor Slider::CreateValueDisplay()
596 Actor popup = Actor::New();
597 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
598 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
600 mPopupArrow = CreatePopupArrow();
601 popup.Add( mPopupArrow );
603 mPopup = CreatePopup();
604 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
605 mPopupArrow.Add( mPopup );
610 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
612 return mValueChangedSignal;
615 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
617 return mSlidingFinishedSignal;
620 Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
625 void Slider::UpdateSkin()
631 mBacking.SetColor( Color::WHITE );
632 mHandle.SetColor( Color::WHITE );
633 mProgress.SetColor( Color::WHITE );
638 Vector4 disableColor = GetDisableColor();
639 mBacking.SetColor( disableColor );
640 mHandle.SetColor( disableColor );
641 mProgress.SetColor( disableColor );
655 void Slider::CreateChildren()
660 mHitArea = CreateHitRegion();
661 mPanDetector = PanGestureDetector::New();
662 mPanDetector.Attach( mHitArea );
663 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
664 self.Add( mHitArea );
667 mBacking = CreateBacking();
668 self.Add( mBacking );
671 mProgress = CreateProgress();
672 mBacking.Add( mProgress );
675 mHandle = CreateHandle();
676 mBacking.Add( mHandle );
679 void Slider::SetHitRegion( const Vector2& size )
685 mHitArea.SetSize( mHitRegion );
689 const Vector2& Slider::GetHitRegion() const
694 void Slider::AddPopup()
698 mValueDisplay = CreateValueDisplay();
699 mValueDisplay.SetVisible( false );
700 mHandle.Add( mValueDisplay );
702 CreatePopupImage( GetPopupImageName() );
703 CreatePopupArrowImage( GetPopupArrowImageName() );
705 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
706 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
710 void Slider::RemovePopup()
717 mPopupArrow.Unparent();
720 mValueDisplay.Unparent();
721 mValueDisplay.Reset();
723 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
729 float Slider::MarkFilter( float value )
731 const float MARK_TOLERANCE = GetMarkTolerance();
734 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
736 const Property::Value& propertyValue = *it;
737 propertyValue.Get( mark );
738 mark = MapValuePercentage( mark );
740 // If close to a mark, return the mark
741 if( fabsf( mark - value ) < MARK_TOLERANCE )
750 float Slider::SnapToMark( float value )
752 float closestMark = value;
753 float closestDist = std::numeric_limits<float>::max();
756 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
758 const Property::Value& propertyValue = *it;
759 propertyValue.Get( mark );
760 mark = MapValuePercentage( mark );
762 float dist = fabsf( mark - value );
763 if( dist < closestDist )
773 bool Slider::MarkReached( float value, int& outIndex )
775 const float MARK_TOLERANCE = GetMarkTolerance();
779 tail = mMarks.size() - 1;
783 while( head <= tail )
785 current = head + ( tail - head ) / 2;
787 const Property::Value& propertyValue = mMarks[ current ];
788 propertyValue.Get( mark );
789 mark = MapValuePercentage( mark );
791 if( fabsf( mark - value ) < MARK_TOLERANCE )
810 bool Slider::HideValueView()
814 mValueDisplay.SetVisible( false );
820 void Slider::SetLowerBound( float bound )
823 DisplayValue( GetValue(), false );
826 float Slider::GetLowerBound() const
831 void Slider::SetUpperBound( float bound )
834 DisplayValue( GetValue(), false );
837 float Slider::GetUpperBound() const
842 void Slider::SetValue( float value )
845 DisplayValue( mValue, true );
848 float Slider::GetValue() const
853 void Slider::SetBackingRegion( const Vector2& region )
855 mBackingRegion = region;
859 mBacking.SetSize( mBackingRegion );
862 ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
864 mDomain = CalcDomain( mBackingRegion );
866 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
869 const Vector2& Slider::GetBackingRegion() const
871 return mBackingRegion;
874 void Slider::SetHandleRegion( const Vector2& region )
876 mHandleRegionSize = region;
878 ResizeHandleRegion( mHandleRegionSize );
880 Vector2 hitRegion = GetHitRegion();
881 hitRegion.x += mHandleRegionSize.x;
882 SetHitRegion( hitRegion );
885 const Vector2& Slider::GetHandleRegion() const
887 return mHandleRegionSize;
890 void Slider::SetDisableColor( const Vector4& color )
892 mDisableColor = color;
897 Vector4 Slider::GetDisableColor() const
899 return mDisableColor;
902 Vector4 Slider::GetPopupTextColor() const
904 return mPopupTextColor;
907 void Slider::SetValuePrecision( int precision )
909 mValuePrecision = precision;
912 int Slider::GetValuePrecision() const
914 return mValuePrecision;
917 void Slider::SetShowPopup( bool showPopup )
919 mShowPopup = showPopup;
932 bool Slider::GetShowPopup() const
937 void Slider::SetShowValue( bool showValue )
939 mShowValue = showValue;
943 CreateHandleValueDisplay();
947 DestroyHandleValueDisplay();
951 bool Slider::GetShowValue() const
956 void Slider::SetEnabled( bool enabled )
970 bool Slider::IsEnabled() const
972 return mState != DISABLED;
975 void Slider::SetMarkTolerance( float tolerance )
977 mMarkTolerance = tolerance;
980 float Slider::GetMarkTolerance() const
982 return mMarkTolerance;
985 // Static class method to support script connecting signals
986 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
988 Dali::BaseHandle handle( object );
990 bool connected = true;
991 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
993 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
995 slider.ValueChangedSignal().Connect( tracker, functor );
997 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
999 slider.MarkSignal().Connect( tracker, functor );
1003 // signalName does not match any signal
1010 void Slider::DisplayPopup( float value )
1012 // Value displayDoConnectSignal
1013 if( mValueTextLabel )
1015 std::stringstream ss;
1016 ss.precision( GetValuePrecision() );
1017 ss << std::fixed << value;
1018 mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
1022 mValueDisplay.SetVisible( true );
1024 mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1029 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1031 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1035 Slider& sliderImpl( GetImpl( slider ) );
1037 switch ( propertyIndex )
1039 case Toolkit::Slider::Property::LOWER_BOUND:
1041 sliderImpl.SetLowerBound( value.Get< float >() );
1045 case Toolkit::Slider::Property::UPPER_BOUND:
1047 sliderImpl.SetUpperBound( value.Get< float >() );
1051 case Toolkit::Slider::Property::VALUE:
1053 sliderImpl.SetValue( value.Get< float >() );
1057 case Toolkit::Slider::Property::HIT_REGION:
1059 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1063 case Toolkit::Slider::Property::BACKING_REGION:
1065 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1069 case Toolkit::Slider::Property::HANDLE_REGION:
1071 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1075 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1077 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1081 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1083 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1087 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1089 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1093 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1095 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1099 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1101 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1105 case Toolkit::Slider::Property::DISABLE_COLOR:
1107 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1111 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1113 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1117 case Toolkit::Slider::Property::VALUE_PRECISION:
1119 sliderImpl.SetValuePrecision( value.Get< int >() );
1123 case Toolkit::Slider::Property::SHOW_POPUP:
1125 sliderImpl.SetShowPopup( value.Get< bool >() );
1129 case Toolkit::Slider::Property::SHOW_VALUE:
1131 sliderImpl.SetShowValue( value.Get< bool >() );
1135 case Toolkit::Slider::Property::ENABLED:
1137 sliderImpl.SetEnabled( value.Get< bool >() );
1141 case Toolkit::Slider::Property::MARKS:
1143 sliderImpl.SetMarks( value.Get< Property::Array >() );
1147 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1149 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1153 case Toolkit::Slider::Property::MARK_TOLERANCE:
1155 sliderImpl.SetMarkTolerance( value.Get< float >() );
1162 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1164 Property::Value value;
1166 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1170 Slider& sliderImpl( GetImpl( slider ) );
1172 switch ( propertyIndex )
1174 case Toolkit::Slider::Property::LOWER_BOUND:
1176 value = sliderImpl.GetLowerBound();
1180 case Toolkit::Slider::Property::UPPER_BOUND:
1182 value = sliderImpl.GetUpperBound();
1186 case Toolkit::Slider::Property::VALUE:
1188 value = sliderImpl.GetValue();
1192 case Toolkit::Slider::Property::HIT_REGION:
1194 value = sliderImpl.GetHitRegion();
1198 case Toolkit::Slider::Property::BACKING_REGION:
1200 value = sliderImpl.GetBackingRegion();
1204 case Toolkit::Slider::Property::HANDLE_REGION:
1206 value = sliderImpl.GetHandleRegion();
1210 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1212 value = sliderImpl.GetBackingImageName();
1216 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1218 value = sliderImpl.GetHandleImageName();
1222 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1224 value = sliderImpl.GetProgressImageName();
1228 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1230 value = sliderImpl.GetPopupImageName();
1234 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1236 value = sliderImpl.GetPopupArrowImageName();
1240 case Toolkit::Slider::Property::DISABLE_COLOR:
1242 value = sliderImpl.GetDisableColor();
1246 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1248 value = sliderImpl.GetPopupTextColor();
1252 case Toolkit::Slider::Property::VALUE_PRECISION:
1254 value = sliderImpl.GetValuePrecision();
1258 case Toolkit::Slider::Property::SHOW_POPUP:
1260 value = sliderImpl.GetShowPopup();
1264 case Toolkit::Slider::Property::SHOW_VALUE:
1266 value = sliderImpl.GetShowValue();
1270 case Toolkit::Slider::Property::ENABLED:
1272 value = sliderImpl.IsEnabled();
1276 case Toolkit::Slider::Property::MARKS:
1278 // TODO: Need to be able to return a PropertyArray
1279 // value = sliderImpl.GetMarks();
1283 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1285 value = sliderImpl.GetSnapToMarks();
1289 case Toolkit::Slider::Property::MARK_TOLERANCE:
1291 value = sliderImpl.GetMarkTolerance();
1300 } // namespace Internal
1302 } // namespace Toolkit