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, "trackVisual", MAP, TRACK_VISUAL )
60 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleVisual", MAP, HANDLE_VISUAL )
61 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progressVisual", MAP, PROGRESS_VISUAL )
62 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupVisual", MAP, POPUP_VISUAL )
63 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupArrowVisual", MAP, POPUP_ARROW_VISUAL )
64 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disabledColor", VECTOR4, DISABLED_COLOR )
65 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "valuePrecision", INTEGER, VALUE_PRECISION )
66 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showPopup", BOOLEAN, SHOW_POPUP )
67 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showValue", BOOLEAN, SHOW_VALUE )
68 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "marks", ARRAY, MARKS )
69 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snapToMarks", BOOLEAN, SNAP_TO_MARKS )
70 DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "markTolerance", FLOAT, MARK_TOLERANCE )
72 DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED )
73 DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "mark", SIGNAL_MARK )
75 DALI_TYPE_REGISTRATION_END()
77 const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
79 const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec
80 const int VALUE_VIEW_SHOW_DURATION_LONG = 2000; // millisec
82 const float VALUE_VERTICAL_OFFSET = 48.0f;
84 const float DEFAULT_WIDTH = 0.0f;
85 const float DEFAULT_HEIGHT = 27.0f;
86 const float DEFAULT_HIT_HEIGHT = 72.0f;
87 const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
88 const float POPUP_TEXT_PADDING = 10.0f;
90 const char* SKINNED_TRACK_VISUAL = DALI_IMAGE_DIR "slider-skin.9.png";
91 const char* SKINNED_HANDLE_VISUAL = DALI_IMAGE_DIR "slider-skin-handle.png";
92 const char* SKINNED_PROGRESS_VISUAL = DALI_IMAGE_DIR "slider-skin-progress.9.png";
93 const char* SKINNED_POPUP_VISUAL = DALI_IMAGE_DIR "slider-popup.9.png";
94 const char* SKINNED_POPUP_ARROW_VISUAL = DALI_IMAGE_DIR "slider-popup-arrow.png";
96 const Vector2 DEFAULT_HIT_REGION( DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT );
97 const Vector2 DEFAULT_TRACK_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT );
98 const Vector2 DEFAULT_HANDLE_SIZE( DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT );
100 const Vector4 DEFAULT_DISABLED_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
102 const float VALUE_POPUP_MARGIN = 10.0f;
103 const float VALUE_POPUP_HEIGHT = 81.0f;
104 const float VALUE_POPUP_MIN_WIDTH = 54.0f;
105 const Vector2 VALUE_POPUP_ARROW_SIZE( 18.0f, 18.0f );
107 const float DEFAULT_LOWER_BOUND = 0.0f;
108 const float DEFAULT_UPPER_BOUND = 1.0f;
109 const float DEFAULT_VALUE = 0.0f;
110 const int DEFAULT_VALUE_PRECISION = 0;
111 const bool DEFAULT_SHOW_POPUP = false;
112 const bool DEFAULT_SHOW_VALUE = true;
113 const bool DEFAULT_ENABLED = true;
114 const bool DEFAULT_SNAP_TO_MARKS = false;
116 } // Unnamed namespace
118 ///////////////////////////////////////////////////////////////////////////////////////////////////
120 ///////////////////////////////////////////////////////////////////////////////////////////////////
122 Dali::Toolkit::Slider Slider::New()
124 // Create the implementation
125 SliderPtr slider( new Slider() );
127 // Pass ownership to CustomActor via derived handle
128 Dali::Toolkit::Slider handle( *slider );
130 // Second-phase init of the implementation
131 // This can only be done after the CustomActor connection has been made...
132 slider->Initialize();
138 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
141 mPopupArrowVisual(""),
149 mDisabledColor( 0.0f, 0.0f, 0.0f, 0.0f ),
150 mHitRegion( 0.0f, 0.0f ),
151 mTrackRegion( 0.0f, 0.0f ),
152 mHandleSize( 0.0f, 0.0f ),
156 mMarkTolerance( 0.0f ),
157 mValuePrecision( 0 ),
160 mSnapToMarks( false )
168 void Slider::OnInitialize()
176 SetHitRegion( DEFAULT_HIT_REGION );
177 SetTrackRegion( DEFAULT_TRACK_REGION );
178 SetHandleSize( DEFAULT_HANDLE_SIZE );
180 SetTrackVisual( SKINNED_TRACK_VISUAL );
181 SetHandleVisual( SKINNED_HANDLE_VISUAL );
182 SetProgressVisual( SKINNED_PROGRESS_VISUAL );
183 SetPopupVisual( SKINNED_POPUP_VISUAL );
184 SetPopupArrowVisual( SKINNED_POPUP_ARROW_VISUAL );
186 SetShowPopup( DEFAULT_SHOW_POPUP );
187 SetShowValue( DEFAULT_SHOW_VALUE );
189 SetEnabled( DEFAULT_ENABLED );
190 SetDisabledColor( DEFAULT_DISABLED_COLOR );
192 SetSnapToMarks( DEFAULT_SNAP_TO_MARKS );
193 SetMarkTolerance( MARK_SNAP_TOLERANCE );
195 SetLowerBound( DEFAULT_LOWER_BOUND );
196 SetUpperBound( DEFAULT_UPPER_BOUND );
198 SetValuePrecision( DEFAULT_VALUE_PRECISION );
199 mValue = DEFAULT_VALUE;
200 DisplayValue( mValue, false ); // Run this last to display the correct value
202 // Size the Slider actor to a default
203 self.SetSize( DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y );
206 void Slider::OnSizeSet( const Vector3& size )
208 // Factor in handle overshoot into size of track
209 SetHitRegion( Vector2( size.x, GetHitRegion().y ) );
210 SetTrackRegion( Vector2( size.x - GetHandleSize().x, GetTrackRegion().y ) );
213 bool Slider::OnTouchEvent(Actor actor, const TouchEvent& event)
215 if( mState != DISABLED )
217 TouchPoint::State touchState = event.GetPoint(0).state;
219 if( touchState == TouchPoint::Down )
223 float percentage = MapPercentage( event.GetPoint(0).local );
224 float value = MapBounds( ( GetSnapToMarks() ) ? SnapToMark( percentage ) : MarkFilter( percentage ), GetLowerBound(), GetUpperBound() );
226 DisplayPopup( value );
228 else if( touchState == TouchPoint::Up)
230 if( mState == PRESSED )
233 mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
241 void Slider::OnPan( Actor actor, const PanGesture& gesture )
243 // gesture.position is in local actor coordinates
244 if( mState != DISABLED )
246 switch( gesture.state )
248 case Gesture::Continuing:
250 if( mState == PRESSED )
252 float value = MapBounds( MarkFilter ( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
254 DisplayPopup( value );
258 case Gesture::Finished:
260 if( mState == PRESSED )
262 if( GetSnapToMarks() )
264 float value = MapBounds( SnapToMark( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
266 DisplayPopup( value );
268 mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
282 float Slider::HitSpaceToDomain( float x )
284 float halfRegionWidth = GetHitRegion().x * 0.5f;
285 float halfDomainWidth = ( mDomain.to.x - mDomain.from.x ) * 0.5f;
286 float endDiff = halfRegionWidth - halfDomainWidth;
291 float Slider::MapPercentage( const Vector2& point )
293 return Clamp( ( HitSpaceToDomain( point.x ) - mDomain.from.x ) / ( mDomain.to.x - mDomain.from.x ), 0.0f, 1.0f );
296 float Slider::MapValuePercentage( float value )
298 return ( value - GetLowerBound() ) / ( GetUpperBound() - GetLowerBound() );
301 float Slider::MapBounds( float percent, float lowerBound, float upperBound )
303 return lowerBound + percent * ( upperBound - lowerBound );
306 Slider::Domain Slider::CalcDomain( const Vector2& currentSize )
308 return Domain( Vector2( 0.0f, 0.0f ), currentSize );
311 void Slider::DisplayValue( float value, bool raiseSignals )
313 float clampledValue = Clamp( value, GetLowerBound(), GetUpperBound() );
315 float percent = MapValuePercentage( clampledValue );
317 float x = mDomain.from.x + percent * ( mDomain.to.x - mDomain.from.x );
324 mProgress.SetSize( x, GetTrackRegion().y );
330 Toolkit::Slider self = Toolkit::Slider::DownCast( Self() );
331 mValueChangedSignal.Emit( self, clampledValue );
334 if( MarkReached( percent, markIndex ) )
336 mMarkReachedSignal.Emit( self, markIndex );
340 if( mHandleValueTextLabel )
342 std::stringstream ss;
343 ss.precision( GetValuePrecision() );
344 ss << std::fixed << clampledValue;
346 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
350 void Slider::SetMarks( const MarkList& marks )
355 const Slider::MarkList& Slider::GetMarks() const
360 void Slider::SetSnapToMarks( bool snap )
365 bool Slider::GetSnapToMarks() const
370 Actor Slider::CreateHitRegion()
372 Actor hitRegion = Actor::New();
373 hitRegion.SetParentOrigin( ParentOrigin::CENTER );
374 hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
375 hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
380 Toolkit::ImageView Slider::CreateTrack()
382 Toolkit::ImageView track = Toolkit::ImageView::New();
383 track.SetParentOrigin( ParentOrigin::CENTER );
384 track.SetAnchorPoint( AnchorPoint::CENTER );
389 void Slider::SetTrackVisual( const std::string& filename )
391 if( mHandle && ( filename.size() > 0 ) )
393 mTrack.SetImage( filename );
394 mTrackVisual = filename;
398 void Slider::SetTrackVisual( Property::Map map )
400 Property::Value* imageValue = map.Find( "url" );
403 mTrackVisual.clear();
404 std::string filename;
405 if( imageValue->Get( filename ) )
407 if( mTrack && ( filename.size() > 0 ) )
409 mTrack.SetImage( filename );
415 Property::Value* sizeValue = map.Find( "size" );
419 if( sizeValue->Get( size ) )
424 mTrack.SetSize( mTrackRegion );
427 ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
429 mDomain = CalcDomain( mTrackRegion );
431 // Set the progress bar to correct width
432 DisplayValue( GetValue(), false );
437 std::string Slider::GetTrackVisual()
442 Toolkit::ImageView Slider::CreateProgress()
444 Toolkit::ImageView progress = Toolkit::ImageView::New();
445 progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
446 progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
451 void Slider::SetProgressVisual( const std::string& filename )
453 if( mProgress && ( filename.size() > 0 ) )
455 mProgress.SetImage( filename );
456 mProgressVisual = filename;
460 void Slider::SetProgressVisual( Property::Map map )
462 Property::Value* imageValue = map.Find( "url" );
465 mProgressVisual.clear();
466 std::string filename;
467 if( imageValue->Get( filename ) )
469 if( mProgress && ( filename.size() > 0 ) )
471 mProgress.SetImage( filename );
478 std::string Slider::GetProgressVisual()
480 return mProgressVisual;
483 void Slider::SetPopupVisual( const std::string& filename )
485 mPopupVisual = filename;
488 void Slider::SetPopupVisual( Property::Map map )
490 Property::Value* imageValue = map.Find( "url" );
493 mPopupVisual.clear();
494 std::string filename;
495 if( imageValue->Get( filename ) )
497 if( mPopup && ( filename.size() > 0 ) )
499 mPopup.SetImage( filename );
506 std::string Slider::GetPopupVisual()
511 void Slider::CreatePopupImage( const std::string& filename )
513 if( mPopup && ( filename.size() > 0 ) )
515 Image image = ResourceImage::New( filename );
516 mPopup.SetImage( image );
520 void Slider::SetPopupArrowVisual( const std::string& filename )
522 mPopupArrowVisual = filename;
525 void Slider::SetPopupArrowVisual( Property::Map map )
527 Property::Value* imageValue = map.Find( "url" );
530 mPopupArrowVisual.clear();
531 std::string filename;
532 if( imageValue->Get( filename ) )
534 if( mPopupArrow && ( filename.size() > 0 ) )
536 mPopupArrow.SetImage( filename );
537 mPopupArrowMap = map;
543 std::string Slider::GetPopupArrowVisual()
545 return mPopupArrowVisual;
548 void Slider::CreatePopupArrowImage( const std::string& filename )
550 if( mPopupArrow && ( filename.size() > 0 ) )
552 Image image = ResourceImage::New( filename );
553 mPopupArrow.SetImage( image );
557 void Slider::ResizeProgressRegion( const Vector2& region )
561 mProgress.SetSize( region );
565 Toolkit::ImageView Slider::CreateHandle()
567 Toolkit::ImageView handle = Toolkit::ImageView::New();
568 handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
569 handle.SetAnchorPoint( AnchorPoint::CENTER );
574 Toolkit::ImageView Slider::CreatePopupArrow()
576 Toolkit::ImageView arrow = Toolkit::ImageView::New();
577 arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
578 arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
583 Toolkit::TextLabel Slider::CreatePopupText()
585 Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
586 textLabel.SetParentOrigin( ParentOrigin::CENTER );
587 textLabel.SetAnchorPoint( AnchorPoint::CENTER );
588 textLabel.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
589 textLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
590 textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
591 textLabel.SetPadding( Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) );
595 Toolkit::ImageView Slider::CreatePopup()
597 Toolkit::ImageView popup = Toolkit::ImageView::New();
598 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
599 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
600 popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
602 mValueTextLabel = CreatePopupText();
603 popup.Add( mValueTextLabel );
608 void Slider::SetHandleVisual( const std::string& filename )
610 if( mHandle && ( filename.size() > 0 ) )
612 mHandle.SetImage( filename );
613 mHandleVisual = filename;
617 void Slider::SetHandleVisual( Property::Map map )
619 Property::Value* imageValue = map.Find( "url" );
622 mHandleVisual.clear();
623 std::string filename;
624 if( imageValue->Get( filename ) )
626 if( mHandle && ( filename.size() > 0 ) )
628 mHandle.SetImage( filename );
634 Property::Value* sizeValue = map.Find( "size" );
638 if( sizeValue->Get( size ) )
641 ResizeHandleSize( mHandleSize );
643 Vector2 hitRegion = GetHitRegion();
644 hitRegion.x += mHandleSize.x;
645 SetHitRegion( hitRegion );
650 std::string Slider::GetHandleVisual()
652 return mHandleVisual;
655 void Slider::ResizeHandleSize( const Vector2& size )
659 mHandle.SetSize( size );
663 void Slider::CreateHandleValueDisplay()
665 if( mHandle && !mHandleValueTextLabel )
667 mHandleValueTextLabel = Toolkit::TextLabel::New();
668 mHandleValueTextLabel.SetParentOrigin( ParentOrigin::CENTER );
669 mHandleValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER );
670 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
671 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
672 mHandle.Add( mHandleValueTextLabel );
676 void Slider::DestroyHandleValueDisplay()
678 UnparentAndReset(mHandleValueTextLabel);
681 Actor Slider::CreateValueDisplay()
683 Actor popup = Actor::New();
684 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
685 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
687 mPopupArrow = CreatePopupArrow();
688 popup.Add( mPopupArrow );
690 mPopup = CreatePopup();
691 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
692 mPopupArrow.Add( mPopup );
697 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
699 return mValueChangedSignal;
702 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
704 return mSlidingFinishedSignal;
707 Toolkit::Slider::MarkReachedSignalType& Slider::MarkReachedSignal()
709 return mMarkReachedSignal;
712 void Slider::UpdateSkin()
718 mTrack.SetColor( Color::WHITE );
719 mHandle.SetColor( Color::WHITE );
720 mProgress.SetColor( Color::WHITE );
725 Vector4 disabledColor = GetDisabledColor();
726 mTrack.SetColor( disabledColor );
727 mHandle.SetColor( disabledColor );
728 mProgress.SetColor( disabledColor );
742 void Slider::CreateChildren()
747 mHitArea = CreateHitRegion();
748 mPanDetector = PanGestureDetector::New();
749 mPanDetector.Attach( mHitArea );
750 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
751 self.Add( mHitArea );
754 mTrack = CreateTrack();
758 mProgress = CreateProgress();
759 mTrack.Add( mProgress );
762 mHandle = CreateHandle();
763 mProgress.Add( mHandle );
766 void Slider::SetHitRegion( const Vector2& size )
772 mHitArea.SetSize( mHitRegion );
776 const Vector2& Slider::GetHitRegion() const
781 void Slider::AddPopup()
785 mValueDisplay = CreateValueDisplay();
786 mValueDisplay.SetVisible( false );
787 mHandle.Add( mValueDisplay );
789 CreatePopupImage( GetPopupVisual() );
790 CreatePopupArrowImage( GetPopupArrowVisual() );
792 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
793 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
797 void Slider::RemovePopup()
804 mPopupArrow.Unparent();
807 mValueDisplay.Unparent();
808 mValueDisplay.Reset();
810 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
816 float Slider::MarkFilter( float value )
818 const float MARK_TOLERANCE = GetMarkTolerance();
821 for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i)
823 const Property::Value& propertyValue = mMarks[i];
824 propertyValue.Get( mark );
825 mark = MapValuePercentage( mark );
827 // If close to a mark, return the mark
828 if( fabsf( mark - value ) < MARK_TOLERANCE )
837 float Slider::SnapToMark( float value )
839 float closestMark = value;
840 float closestDist = std::numeric_limits<float>::max();
843 for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i)
845 const Property::Value& propertyValue = mMarks[i];
846 propertyValue.Get( mark );
847 mark = MapValuePercentage( mark );
849 float dist = fabsf( mark - value );
850 if( dist < closestDist )
860 bool Slider::MarkReached( float value, int& outIndex )
862 const float MARK_TOLERANCE = GetMarkTolerance();
866 tail = mMarks.Size() - 1;
870 while( head <= tail )
872 current = head + ( tail - head ) / 2;
874 const Property::Value& propertyValue = mMarks[ current ];
875 propertyValue.Get( mark );
876 mark = MapValuePercentage( mark );
878 if( fabsf( mark - value ) < MARK_TOLERANCE )
897 bool Slider::HideValueView()
901 mValueDisplay.SetVisible( false );
907 void Slider::SetLowerBound( float bound )
910 DisplayValue( GetValue(), false );
913 float Slider::GetLowerBound() const
918 void Slider::SetUpperBound( float bound )
921 DisplayValue( GetValue(), false );
924 float Slider::GetUpperBound() const
929 void Slider::SetValue( float value )
932 DisplayValue( mValue, true );
935 float Slider::GetValue() const
940 void Slider::SetTrackRegion( const Vector2& region )
942 mTrackRegion = region;
946 mTrack.SetSize( mTrackRegion );
949 ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
951 mDomain = CalcDomain( mTrackRegion );
953 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
956 const Vector2& Slider::GetTrackRegion() const
961 void Slider::SetHandleSize( const Vector2& size )
965 ResizeHandleSize( mHandleSize );
967 Vector2 hitRegion = GetHitRegion();
968 hitRegion.x += mHandleSize.x;
969 SetHitRegion( hitRegion );
972 const Vector2& Slider::GetHandleSize() const
977 void Slider::SetDisabledColor( const Vector4& color )
979 mDisabledColor = color;
984 Vector4 Slider::GetDisabledColor() const
986 return mDisabledColor;
989 void Slider::SetValuePrecision( int precision )
991 mValuePrecision = precision;
994 int Slider::GetValuePrecision() const
996 return mValuePrecision;
999 void Slider::SetShowPopup( bool showPopup )
1001 mShowPopup = showPopup;
1014 bool Slider::GetShowPopup() const
1019 void Slider::SetShowValue( bool showValue )
1021 mShowValue = showValue;
1025 CreateHandleValueDisplay();
1029 DestroyHandleValueDisplay();
1033 bool Slider::GetShowValue() const
1038 void Slider::SetEnabled( bool enabled )
1052 bool Slider::IsEnabled() const
1054 return mState != DISABLED;
1057 void Slider::SetMarkTolerance( float tolerance )
1059 mMarkTolerance = tolerance;
1062 float Slider::GetMarkTolerance() const
1064 return mMarkTolerance;
1067 // Static class method to support script connecting signals
1068 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
1070 Dali::BaseHandle handle( object );
1072 bool connected = true;
1073 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
1075 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
1077 slider.ValueChangedSignal().Connect( tracker, functor );
1079 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
1081 slider.MarkReachedSignal().Connect( tracker, functor );
1085 // signalName does not match any signal
1092 void Slider::DisplayPopup( float value )
1094 // Value displayDoConnectSignal
1095 if( mValueTextLabel )
1097 std::stringstream ss;
1098 ss.precision( GetValuePrecision() );
1099 ss << std::fixed << value;
1100 mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
1104 mValueDisplay.SetVisible( true );
1106 mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1111 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1113 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1117 Slider& sliderImpl( GetImpl( slider ) );
1119 switch ( propertyIndex )
1121 case Toolkit::Slider::Property::LOWER_BOUND:
1123 sliderImpl.SetLowerBound( value.Get< float >() );
1127 case Toolkit::Slider::Property::UPPER_BOUND:
1129 sliderImpl.SetUpperBound( value.Get< float >() );
1133 case Toolkit::Slider::Property::VALUE:
1135 sliderImpl.SetValue( value.Get< float >() );
1139 case Toolkit::Slider::Property::TRACK_VISUAL:
1142 if( value.Get( map ) )
1144 sliderImpl.SetTrackVisual( map );
1149 case Toolkit::Slider::Property::HANDLE_VISUAL:
1152 if( value.Get( map ) )
1154 sliderImpl.SetHandleVisual( map );
1159 case Toolkit::Slider::Property::PROGRESS_VISUAL:
1162 if( value.Get( map ) )
1164 sliderImpl.SetProgressVisual( map );
1169 case Toolkit::Slider::Property::POPUP_VISUAL:
1171 std::string imageUrl;
1172 if( value.Get( imageUrl ) )
1174 sliderImpl.SetPopupVisual( imageUrl );
1177 // If it is not a string, then get a Property::Map from the property if possible.
1179 if( value.Get( map ) )
1181 sliderImpl.SetPopupVisual( map );
1187 case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1190 if( value.Get( map ) )
1192 sliderImpl.SetPopupArrowVisual( map );
1197 case Toolkit::Slider::Property::DISABLED_COLOR:
1199 sliderImpl.SetDisabledColor( value.Get< Vector4 >() );
1203 case Toolkit::Slider::Property::VALUE_PRECISION:
1205 sliderImpl.SetValuePrecision( value.Get< int >() );
1209 case Toolkit::Slider::Property::SHOW_POPUP:
1211 sliderImpl.SetShowPopup( value.Get< bool >() );
1215 case Toolkit::Slider::Property::SHOW_VALUE:
1217 sliderImpl.SetShowValue( value.Get< bool >() );
1221 case Toolkit::Slider::Property::MARKS:
1223 sliderImpl.SetMarks( value.Get< Property::Array >() );
1227 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1229 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1233 case Toolkit::Slider::Property::MARK_TOLERANCE:
1235 sliderImpl.SetMarkTolerance( value.Get< float >() );
1242 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1244 Property::Value value;
1246 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1250 Slider& sliderImpl( GetImpl( slider ) );
1252 switch ( propertyIndex )
1254 case Toolkit::Slider::Property::LOWER_BOUND:
1256 value = sliderImpl.GetLowerBound();
1260 case Toolkit::Slider::Property::UPPER_BOUND:
1262 value = sliderImpl.GetUpperBound();
1266 case Toolkit::Slider::Property::VALUE:
1268 value = sliderImpl.GetValue();
1272 case Toolkit::Slider::Property::TRACK_VISUAL:
1274 if( !sliderImpl.mTrackVisual.empty() )
1276 value = sliderImpl.GetTrackVisual();
1278 else if( !sliderImpl.mTrackMap.Empty() )
1280 value = sliderImpl.mTrackMap;
1285 case Toolkit::Slider::Property::HANDLE_VISUAL:
1287 if( !sliderImpl.mHandleVisual.empty() )
1289 value = sliderImpl.GetHandleVisual();
1291 else if( !sliderImpl.mHandleMap.Empty() )
1293 value = sliderImpl.mHandleMap;
1298 case Toolkit::Slider::Property::PROGRESS_VISUAL:
1300 if( !sliderImpl.mProgressVisual.empty() )
1302 value = sliderImpl.GetProgressVisual();
1304 else if( !sliderImpl.mProgressMap.Empty() )
1306 value = sliderImpl.mProgressMap;
1311 case Toolkit::Slider::Property::POPUP_VISUAL:
1313 if( !sliderImpl.mPopupVisual.empty() )
1315 value = sliderImpl.GetPopupVisual();
1317 else if( !sliderImpl.mPopupMap.Empty() )
1319 value = sliderImpl.mPopupMap;
1324 case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
1326 if( !sliderImpl.mPopupArrowVisual.empty() )
1328 value = sliderImpl.GetPopupArrowVisual();
1330 else if( !sliderImpl.mPopupArrowMap.Empty() )
1332 value = sliderImpl.mPopupArrowMap;
1337 case Toolkit::Slider::Property::DISABLED_COLOR:
1339 value = sliderImpl.GetDisabledColor();
1343 case Toolkit::Slider::Property::VALUE_PRECISION:
1345 value = sliderImpl.GetValuePrecision();
1349 case Toolkit::Slider::Property::SHOW_POPUP:
1351 value = sliderImpl.GetShowPopup();
1355 case Toolkit::Slider::Property::SHOW_VALUE:
1357 value = sliderImpl.GetShowValue();
1361 case Toolkit::Slider::Property::MARKS:
1363 // TODO: Need to be able to return a PropertyArray
1364 // value = sliderImpl.GetMarks();
1368 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1370 value = sliderImpl.GetSnapToMarks();
1374 case Toolkit::Slider::Property::MARK_TOLERANCE:
1376 value = sliderImpl.GetMarkTolerance();
1385 } // namespace Internal
1387 } // namespace Toolkit