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>
22 #include <cstring> // for strcmp
25 #include <dali/public-api/events/touch-event.h>
26 #include <dali/public-api/object/type-registry.h>
27 #include <dali/public-api/object/type-registry-helper.h>
28 #include <dali/public-api/images/resource-image.h>
31 #include <dali-toolkit/public-api/controls/control-impl.h>
32 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
45 namespace // Unnamed namespace
50 return Dali::Toolkit::Slider::New();
53 // Setup properties, signals and actions using the type-registry.
54 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create )
56 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "lowerBound", FLOAT, LOWER_BOUND )
57 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "upperBound", FLOAT, UPPER_BOUND )
58 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "value", FLOAT, VALUE )
59 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "hitRegion", VECTOR2, HIT_REGION )
60 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backingRegion", VECTOR2, BACKING_REGION )
61 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleRegion", VECTOR2, HANDLE_REGION )
62 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backingImageName", STRING, BACKING_IMAGE_NAME )
63 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleImageName", STRING, HANDLE_IMAGE_NAME )
64 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progressImageName", STRING, PROGRESS_IMAGE_NAME )
65 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupImageName", STRING, POPUP_IMAGE_NAME )
66 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupArrowImageName", STRING, POPUP_ARROW_IMAGE_NAME )
67 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disableColor", VECTOR4, DISABLE_COLOR )
68 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupTextColor", VECTOR4, POPUP_TEXT_COLOR )
69 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "valuePrecision", INTEGER, VALUE_PRECISION )
70 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showPopup", BOOLEAN, SHOW_POPUP )
71 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showValue", BOOLEAN, SHOW_VALUE )
72 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "enabled", BOOLEAN, ENABLED )
73 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "marks", ARRAY, MARKS )
74 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snapToMarks", BOOLEAN, SNAP_TO_MARKS )
75 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "markTolerance", FLOAT, MARK_TOLERANCE )
77 DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED )
78 DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "mark", SIGNAL_MARK )
80 DALI_TYPE_REGISTRATION_END()
82 const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
84 const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec
85 const int VALUE_VIEW_SHOW_DURATION_LONG = 2000; // millisec
87 const float VALUE_VERTICAL_OFFSET = 48.0f;
89 const float DEFAULT_WIDTH = 0.0f;
90 const float DEFAULT_HEIGHT = 27.0f;
91 const float DEFAULT_HIT_HEIGHT = 72.0f;
92 const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
93 const float POPUP_TEXT_PADDING = 10.0f;
95 const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.9.png";
96 const char* SKINNED_HANDLE_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-handle.png";;
97 const char* SKINNED_PROGRESS_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-progress.9.png";
98 const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.9.png";
99 const char* SKINNED_POPUP_ARROW_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup-arrow.png";
101 const Vector2 DEFAULT_HIT_REGION( DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT );
102 const Vector2 DEFAULT_BACKING_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT );
103 const Vector2 DEFAULT_HANDLE_REGION( DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT );
105 const Vector4 DEFAULT_DISABLE_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
106 const Vector4 DEFAULT_POPUP_TEXT_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
108 const float VALUE_POPUP_MARGIN = 10.0f;
109 const float VALUE_POPUP_HEIGHT = 81.0f;
110 const float VALUE_POPUP_MIN_WIDTH = 54.0f;
111 const Vector2 VALUE_POPUP_ARROW_SIZE( 18.0f, 18.0f );
113 const float DEFAULT_LOWER_BOUND = 0.0f;
114 const float DEFAULT_UPPER_BOUND = 1.0f;
115 const float DEFAULT_VALUE = 0.0f;
116 const int DEFAULT_VALUE_PRECISION = 0;
117 const bool DEFAULT_SHOW_POPUP = false;
118 const bool DEFAULT_SHOW_VALUE = true;
119 const bool DEFAULT_ENABLED = true;
120 const bool DEFAULT_SNAP_TO_MARKS = false;
122 } // Unnamed namespace
124 ///////////////////////////////////////////////////////////////////////////////////////////////////
126 ///////////////////////////////////////////////////////////////////////////////////////////////////
128 Dali::Toolkit::Slider Slider::New()
130 // Create the implementation
131 SliderPtr slider( new Slider() );
133 // Pass ownership to CustomActor via derived handle
134 Dali::Toolkit::Slider handle( *slider );
136 // Second-phase init of the implementation
137 // This can only be done after the CustomActor connection has been made...
138 slider->Initialize();
144 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
147 mPopupArrowImageName(""),
148 mBackingImageName(""),
149 mHandleImageName(""),
150 mProgressImageName(""),
151 mDisableColor( 0.0f, 0.0f, 0.0f, 0.0f ),
152 mPopupTextColor( 0.0f, 0.0f, 0.0f, 0.0f ),
153 mHitRegion( 0.0f, 0.0f ),
154 mBackingRegion( 0.0f, 0.0f ),
155 mHandleRegionSize( 0.0f, 0.0f ),
159 mMarkTolerance( 0.0f ),
160 mValuePrecision( 0 ),
163 mSnapToMarks( false )
171 void Slider::OnInitialize()
179 SetHitRegion( DEFAULT_HIT_REGION );
180 SetBackingRegion( DEFAULT_BACKING_REGION );
181 SetHandleRegion( DEFAULT_HANDLE_REGION );
183 SetBackingImageName( SKINNED_BACKING_IMAGE_NAME );
184 SetHandleImageName( SKINNED_HANDLE_IMAGE_NAME );
185 SetProgressImageName( SKINNED_PROGRESS_IMAGE_NAME );
186 SetPopupImageName( SKINNED_POPUP_IMAGE_NAME );
187 SetPopupArrowImageName( SKINNED_POPUP_ARROW_IMAGE_NAME );
189 SetPopupTextColor( DEFAULT_POPUP_TEXT_COLOR );
191 SetShowPopup( DEFAULT_SHOW_POPUP );
192 SetShowValue( DEFAULT_SHOW_VALUE );
194 SetEnabled( DEFAULT_ENABLED );
195 SetDisableColor( DEFAULT_DISABLE_COLOR );
197 SetSnapToMarks( DEFAULT_SNAP_TO_MARKS );
198 SetMarkTolerance( MARK_SNAP_TOLERANCE );
200 SetLowerBound( DEFAULT_LOWER_BOUND );
201 SetUpperBound( DEFAULT_UPPER_BOUND );
203 SetValuePrecision( DEFAULT_VALUE_PRECISION );
204 mValue = DEFAULT_VALUE;
205 DisplayValue( mValue, false ); // Run this last to display the correct value
207 // Size the Slider actor to a default
208 self.SetSize( DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y );
211 void Slider::OnSizeSet( const Vector3& size )
213 // Factor in handle overshoot into size of backing
214 SetHitRegion( Vector2( size.x, GetHitRegion().y ) );
215 SetBackingRegion( Vector2( size.x - GetHandleRegion().x, GetBackingRegion().y ) );
218 bool Slider::OnTouchEvent(Actor actor, const TouchEvent& event)
220 if( mState != DISABLED )
222 TouchPoint::State touchState = event.GetPoint(0).state;
224 if( touchState == TouchPoint::Down )
228 float percentage = MapPercentage( event.GetPoint(0).local );
229 float value = MapBounds( ( GetSnapToMarks() ) ? SnapToMark( percentage ) : MarkFilter( percentage ), GetLowerBound(), GetUpperBound() );
231 DisplayPopup( value );
233 else if( touchState == TouchPoint::Up)
235 if( mState == PRESSED )
238 mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
246 void Slider::OnPan( Actor actor, const PanGesture& gesture )
248 // gesture.position is in local actor coordinates
249 if( mState != DISABLED )
251 switch( gesture.state )
253 case Gesture::Continuing:
255 if( mState == PRESSED )
257 float value = MapBounds( MarkFilter ( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
259 DisplayPopup( value );
263 case Gesture::Finished:
265 if( mState == PRESSED )
267 if( GetSnapToMarks() )
269 float value = MapBounds( SnapToMark( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
271 DisplayPopup( value );
273 mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
287 float Slider::HitSpaceToDomain( float x )
289 float halfRegionWidth = GetHitRegion().x * 0.5f;
290 float halfDomainWidth = ( mDomain.to.x - mDomain.from.x ) * 0.5f;
291 float endDiff = halfRegionWidth - halfDomainWidth;
296 float Slider::MapPercentage( const Vector2& point )
298 return Clamp( ( HitSpaceToDomain( point.x ) - mDomain.from.x ) / ( mDomain.to.x - mDomain.from.x ), 0.0f, 1.0f );
301 float Slider::MapValuePercentage( float value )
303 return ( value - GetLowerBound() ) / ( GetUpperBound() - GetLowerBound() );
306 float Slider::MapBounds( float percent, float lowerBound, float upperBound )
308 return lowerBound + percent * ( upperBound - lowerBound );
311 Slider::Domain Slider::CalcDomain( const Vector2& currentSize )
313 return Domain( Vector2( 0.0f, 0.0f ), currentSize );
316 void Slider::DisplayValue( float value, bool raiseSignals )
318 float clampledValue = Clamp( value, GetLowerBound(), GetUpperBound() );
320 float percent = MapValuePercentage( clampledValue );
322 float x = mDomain.from.x + percent * ( mDomain.to.x - mDomain.from.x );
329 mProgress.SetSize( x, GetBackingRegion().y );
335 Toolkit::Slider self = Toolkit::Slider::DownCast( Self() );
336 mValueChangedSignal.Emit( self, clampledValue );
339 if( MarkReached( percent, markIndex ) )
341 mMarkSignal.Emit( self, markIndex );
345 if( mHandleValueTextLabel )
347 std::stringstream ss;
348 ss.precision( GetValuePrecision() );
349 ss << std::fixed << clampledValue;
351 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
355 void Slider::SetMarks( const MarkList& marks )
360 const Slider::MarkList& Slider::GetMarks() const
365 void Slider::SetSnapToMarks( bool snap )
370 bool Slider::GetSnapToMarks() const
375 Actor Slider::CreateHitRegion()
377 Actor hitRegion = Actor::New();
378 hitRegion.SetParentOrigin( ParentOrigin::CENTER );
379 hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
380 hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
385 Toolkit::ImageView Slider::CreateBacking()
387 Toolkit::ImageView backing = Toolkit::ImageView::New();
388 backing.SetParentOrigin( ParentOrigin::CENTER );
389 backing.SetAnchorPoint( AnchorPoint::CENTER );
394 void Slider::SetBackingImageName( const std::string& imageName )
396 if( mBacking && ( imageName.size() > 0 ) )
398 mBacking.SetImage( imageName );
399 mBackingImageName = imageName;
403 std::string Slider::GetBackingImageName()
405 return mBackingImageName;
408 Toolkit::ImageView Slider::CreateProgress()
410 Toolkit::ImageView progress = Toolkit::ImageView::New();
411 progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
412 progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
417 void Slider::SetProgressImageName( const std::string& imageName )
419 if( mProgress && ( imageName.size() > 0 ) )
421 mProgress.SetImage( imageName );
422 mProgressImageName = imageName;
426 std::string Slider::GetProgressImageName()
428 return mProgressImageName;
431 void Slider::SetPopupImageName( const std::string& imageName )
433 mPopupImageName = imageName;
436 std::string Slider::GetPopupImageName()
438 return mPopupImageName;
441 void Slider::CreatePopupImage( const std::string& imageName )
443 if( mPopup && ( imageName.size() > 0 ) )
445 Image image = ResourceImage::New( imageName );
446 mPopup.SetImage( image );
450 void Slider::SetPopupArrowImageName( const std::string& imageName )
452 mPopupArrowImageName = imageName;
455 std::string Slider::GetPopupArrowImageName()
457 return mPopupArrowImageName;
460 void Slider::CreatePopupArrowImage( const std::string& imageName )
462 if( mPopupArrow && ( imageName.size() > 0 ) )
464 Image image = ResourceImage::New( imageName );
465 mPopupArrow.SetImage( image );
469 void Slider::ResizeProgressRegion( const Vector2& region )
473 mProgress.SetSize( region );
477 Toolkit::ImageView Slider::CreateHandle()
479 Toolkit::ImageView handle = Toolkit::ImageView::New();
480 handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
481 handle.SetAnchorPoint( AnchorPoint::CENTER );
486 Toolkit::ImageView Slider::CreatePopupArrow()
488 Toolkit::ImageView arrow = Toolkit::ImageView::New();
489 arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
490 arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
495 Toolkit::TextLabel Slider::CreatePopupText()
497 Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
498 textLabel.SetParentOrigin( ParentOrigin::CENTER );
499 textLabel.SetAnchorPoint( AnchorPoint::CENTER );
500 textLabel.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
501 textLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
502 textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
503 textLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, DEFAULT_POPUP_TEXT_COLOR );
504 textLabel.SetPadding( Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) );
508 Toolkit::ImageView Slider::CreatePopup()
510 Toolkit::ImageView popup = Toolkit::ImageView::New();
511 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
512 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
513 popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
515 mValueTextLabel = CreatePopupText();
516 popup.Add( mValueTextLabel );
521 void Slider::SetHandleImageName( const std::string& imageName )
523 if( mHandle && ( imageName.size() > 0 ) )
525 mHandle.SetImage( imageName );
526 mHandleImageName = imageName;
530 std::string Slider::GetHandleImageName()
532 return mHandleImageName;
535 void Slider::ResizeHandleRegion( const Vector2& region )
539 mHandle.SetSize( region );
543 void Slider::CreateHandleValueDisplay()
545 if( mHandle && !mHandleValueTextLabel )
547 mHandleValueTextLabel = Toolkit::TextLabel::New();
548 mHandleValueTextLabel.SetParentOrigin( ParentOrigin::CENTER );
549 mHandleValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER );
550 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
551 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
552 mHandle.Add( mHandleValueTextLabel );
556 void Slider::DestroyHandleValueDisplay()
558 UnparentAndReset(mHandleValueTextLabel);
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 mProgress.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::SizeType i = 0; i < mMarks.Count(); ++i)
708 const Property::Value& propertyValue = mMarks[i];
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::SizeType i = 0; i < mMarks.Count(); ++i)
730 const Property::Value& propertyValue = mMarks[i];
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 )
984 // Value displayDoConnectSignal
985 if( mValueTextLabel )
987 std::stringstream ss;
988 ss.precision( GetValuePrecision() );
989 ss << std::fixed << value;
990 mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
994 mValueDisplay.SetVisible( true );
996 mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1001 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1003 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1007 Slider& sliderImpl( GetImpl( slider ) );
1009 switch ( propertyIndex )
1011 case Toolkit::Slider::Property::LOWER_BOUND:
1013 sliderImpl.SetLowerBound( value.Get< float >() );
1017 case Toolkit::Slider::Property::UPPER_BOUND:
1019 sliderImpl.SetUpperBound( value.Get< float >() );
1023 case Toolkit::Slider::Property::VALUE:
1025 sliderImpl.SetValue( value.Get< float >() );
1029 case Toolkit::Slider::Property::HIT_REGION:
1031 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1035 case Toolkit::Slider::Property::BACKING_REGION:
1037 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1041 case Toolkit::Slider::Property::HANDLE_REGION:
1043 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1047 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1049 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1053 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1055 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1059 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1061 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1065 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1067 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1071 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1073 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1077 case Toolkit::Slider::Property::DISABLE_COLOR:
1079 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1083 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1085 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1089 case Toolkit::Slider::Property::VALUE_PRECISION:
1091 sliderImpl.SetValuePrecision( value.Get< int >() );
1095 case Toolkit::Slider::Property::SHOW_POPUP:
1097 sliderImpl.SetShowPopup( value.Get< bool >() );
1101 case Toolkit::Slider::Property::SHOW_VALUE:
1103 sliderImpl.SetShowValue( value.Get< bool >() );
1107 case Toolkit::Slider::Property::ENABLED:
1109 sliderImpl.SetEnabled( value.Get< bool >() );
1113 case Toolkit::Slider::Property::MARKS:
1115 sliderImpl.SetMarks( value.Get< Property::Array >() );
1119 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1121 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1125 case Toolkit::Slider::Property::MARK_TOLERANCE:
1127 sliderImpl.SetMarkTolerance( value.Get< float >() );
1134 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1136 Property::Value value;
1138 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1142 Slider& sliderImpl( GetImpl( slider ) );
1144 switch ( propertyIndex )
1146 case Toolkit::Slider::Property::LOWER_BOUND:
1148 value = sliderImpl.GetLowerBound();
1152 case Toolkit::Slider::Property::UPPER_BOUND:
1154 value = sliderImpl.GetUpperBound();
1158 case Toolkit::Slider::Property::VALUE:
1160 value = sliderImpl.GetValue();
1164 case Toolkit::Slider::Property::HIT_REGION:
1166 value = sliderImpl.GetHitRegion();
1170 case Toolkit::Slider::Property::BACKING_REGION:
1172 value = sliderImpl.GetBackingRegion();
1176 case Toolkit::Slider::Property::HANDLE_REGION:
1178 value = sliderImpl.GetHandleRegion();
1182 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1184 value = sliderImpl.GetBackingImageName();
1188 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1190 value = sliderImpl.GetHandleImageName();
1194 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1196 value = sliderImpl.GetProgressImageName();
1200 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1202 value = sliderImpl.GetPopupImageName();
1206 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1208 value = sliderImpl.GetPopupArrowImageName();
1212 case Toolkit::Slider::Property::DISABLE_COLOR:
1214 value = sliderImpl.GetDisableColor();
1218 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1220 value = sliderImpl.GetPopupTextColor();
1224 case Toolkit::Slider::Property::VALUE_PRECISION:
1226 value = sliderImpl.GetValuePrecision();
1230 case Toolkit::Slider::Property::SHOW_POPUP:
1232 value = sliderImpl.GetShowPopup();
1236 case Toolkit::Slider::Property::SHOW_VALUE:
1238 value = sliderImpl.GetShowValue();
1242 case Toolkit::Slider::Property::ENABLED:
1244 value = sliderImpl.IsEnabled();
1248 case Toolkit::Slider::Property::MARKS:
1250 // TODO: Need to be able to return a PropertyArray
1251 // value = sliderImpl.GetMarks();
1255 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1257 value = sliderImpl.GetSnapToMarks();
1261 case Toolkit::Slider::Property::MARK_TOLERANCE:
1263 value = sliderImpl.GetMarkTolerance();
1272 } // namespace Internal
1274 } // namespace Toolkit