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>
44 namespace // Unnamed namespace
49 return Dali::Toolkit::Slider::New();
52 // Setup properties, signals and actions using the type-registry.
53 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create )
55 DALI_PROPERTY_REGISTRATION( Slider, "lower-bound", FLOAT, LOWER_BOUND )
56 DALI_PROPERTY_REGISTRATION( Slider, "upper-bound", FLOAT, UPPER_BOUND )
57 DALI_PROPERTY_REGISTRATION( Slider, "value", FLOAT, VALUE )
58 DALI_PROPERTY_REGISTRATION( Slider, "hit-region", VECTOR2, HIT_REGION )
59 DALI_PROPERTY_REGISTRATION( Slider, "backing-region", VECTOR2, BACKING_REGION )
60 DALI_PROPERTY_REGISTRATION( Slider, "handle-region", VECTOR2, HANDLE_REGION )
61 DALI_PROPERTY_REGISTRATION( Slider, "backing-image-name", STRING, BACKING_IMAGE_NAME )
62 DALI_PROPERTY_REGISTRATION( Slider, "handle-image-name", STRING, HANDLE_IMAGE_NAME )
63 DALI_PROPERTY_REGISTRATION( Slider, "progress-image-name", STRING, PROGRESS_IMAGE_NAME )
64 DALI_PROPERTY_REGISTRATION( Slider, "popup-image-name", STRING, POPUP_IMAGE_NAME )
65 DALI_PROPERTY_REGISTRATION( Slider, "popup-arrow-image-name", STRING, POPUP_ARROW_IMAGE_NAME )
66 DALI_PROPERTY_REGISTRATION( Slider, "disable-color", VECTOR4, DISABLE_COLOR )
67 DALI_PROPERTY_REGISTRATION( Slider, "popup-text-color", VECTOR4, POPUP_TEXT_COLOR )
68 DALI_PROPERTY_REGISTRATION( Slider, "value-precision", INTEGER, VALUE_PRECISION )
69 DALI_PROPERTY_REGISTRATION( Slider, "show-popup", BOOLEAN, SHOW_POPUP )
70 DALI_PROPERTY_REGISTRATION( Slider, "show-value", BOOLEAN, SHOW_VALUE )
71 DALI_PROPERTY_REGISTRATION( Slider, "enabled", BOOLEAN, ENABLED )
72 DALI_PROPERTY_REGISTRATION( Slider, "marks", ARRAY, MARKS )
73 DALI_PROPERTY_REGISTRATION( Slider, "snap-to-marks", BOOLEAN, SNAP_TO_MARKS )
74 DALI_PROPERTY_REGISTRATION( Slider, "mark-tolerance", FLOAT, MARK_TOLERANCE )
76 DALI_SIGNAL_REGISTRATION( Slider, "value-changed", SIGNAL_VALUE_CHANGED )
77 DALI_SIGNAL_REGISTRATION( Slider, "mark", SIGNAL_MARK )
79 DALI_TYPE_REGISTRATION_END()
81 const float BACKING_Z = -0.1f;
82 const float PROGRESS_Z = 0.1f;
83 const float HANDLE_Z = 1.0f;
84 const float VALUE_TEXT_INCREMENT = 0.01f;
85 const float HANDLE_VALUE_DISPLAY_TEXT_Z = HANDLE_Z + VALUE_TEXT_INCREMENT;
86 const float VALUE_DISPLAY_TEXT_Z = VALUE_TEXT_INCREMENT + VALUE_TEXT_INCREMENT; // Put above HANDLE_VALUE_DISPLAY_TEXT_Z (parented to handle)
88 const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
90 const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec
91 const int VALUE_VIEW_SHOW_DURATION_LONG = 2000; // millisec
93 const float VALUE_VERTICAL_OFFSET = 48.0f;
95 const float DEFAULT_WIDTH = 0.0f;
96 const float DEFAULT_HEIGHT = 27.0f;
97 const float DEFAULT_HIT_HEIGHT = 72.0f;
98 const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
100 const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.9.png";
101 const char* SKINNED_HANDLE_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-handle.png";;
102 const char* SKINNED_PROGRESS_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-progress.9.png";
103 const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.9.png";
104 const char* SKINNED_POPUP_ARROW_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup-arrow.png";
106 const Vector2 DEFAULT_HIT_REGION( DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT );
107 const Vector2 DEFAULT_BACKING_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT );
108 const Vector2 DEFAULT_HANDLE_REGION( DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT );
110 const Vector4 DEFAULT_DISABLE_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
111 const Vector4 DEFAULT_POPUP_TEXT_COLOR( 0.5f, 0.5f, 0.5f, 1.0f );
113 const float VALUE_POPUP_MARGIN = 10.0f;
114 const float VALUE_POPUP_HEIGHT = 81.0f;
115 const float VALUE_POPUP_MIN_WIDTH = 54.0f;
116 const Vector2 VALUE_POPUP_ARROW_SIZE( 18.0f, 18.0f );
118 const float DEFAULT_LOWER_BOUND = 0.0f;
119 const float DEFAULT_UPPER_BOUND = 1.0f;
120 const float DEFAULT_VALUE = 0.0f;
121 const int DEFAULT_VALUE_PRECISION = 0;
122 const bool DEFAULT_SHOW_POPUP = false;
123 const bool DEFAULT_SHOW_VALUE = true;
124 const bool DEFAULT_ENABLED = true;
125 const bool DEFAULT_SNAP_TO_MARKS = false;
127 } // Unnamed namespace
129 ///////////////////////////////////////////////////////////////////////////////////////////////////
131 ///////////////////////////////////////////////////////////////////////////////////////////////////
133 Dali::Toolkit::Slider Slider::New()
135 // Create the implementation
136 SliderPtr slider( new Slider() );
138 // Pass ownership to CustomActor via derived handle
139 Dali::Toolkit::Slider handle( *slider );
141 // Second-phase init of the implementation
142 // This can only be done after the CustomActor connection has been made...
143 slider->Initialize();
149 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
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::OnControlSizeSet( 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 );
324 mHandle.SetPosition( x, 0.0f, HANDLE_Z );
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 )
358 for( MarkList::const_iterator it = marks.begin(), itEnd = marks.end(); it != itEnd; ++it )
360 const Property::Value& propertyValue = *it;
361 propertyValue.Get( value );
363 mMarks.push_back( value );
367 const Slider::MarkList& Slider::GetMarks() const
372 void Slider::SetSnapToMarks( bool snap )
377 bool Slider::GetSnapToMarks() const
382 Actor Slider::CreateHitRegion()
384 Actor hitRegion = Actor::New();
385 hitRegion.SetParentOrigin( ParentOrigin::CENTER );
386 hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
387 hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
392 ImageActor Slider::CreateBacking()
394 ImageActor backing = ImageActor::New();
395 backing.SetRelayoutEnabled( false );
396 backing.SetParentOrigin( ParentOrigin::CENTER );
397 backing.SetAnchorPoint( AnchorPoint::CENTER );
398 backing.SetZ( BACKING_Z );
403 void Slider::SetBackingImageName( const std::string& imageName )
405 if( mBacking && ( imageName.size() > 0 ) )
407 Image image = ResourceImage::New( imageName );
408 mBacking.SetImage( image );
412 std::string Slider::GetBackingImageName()
416 return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
419 return std::string( "" );
422 ImageActor Slider::CreateProgress()
424 ImageActor progress = ImageActor::New();
425 progress.SetRelayoutEnabled( false );
426 progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
427 progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
428 progress.SetZ( PROGRESS_Z );
433 void Slider::SetProgressImageName( const std::string& imageName )
435 if( mProgress && ( imageName.size() > 0 ) )
437 Image image = ResourceImage::New( imageName );
438 mProgress.SetImage( image );
442 std::string Slider::GetProgressImageName()
446 return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
449 return std::string( "" );
452 void Slider::SetPopupImageName( const std::string& imageName )
454 mPopupImageName = imageName;
457 std::string Slider::GetPopupImageName()
459 return mPopupImageName;
462 void Slider::CreatePopupImage( const std::string& imageName )
464 if( mPopup && ( imageName.size() > 0 ) )
466 Image image = ResourceImage::New( imageName );
467 mPopup.SetImage( image );
471 void Slider::SetPopupArrowImageName( const std::string& imageName )
473 mPopupArrowImageName = imageName;
476 std::string Slider::GetPopupArrowImageName()
478 return mPopupArrowImageName;
481 void Slider::CreatePopupArrowImage( const std::string& imageName )
483 if( mPopupArrow && ( imageName.size() > 0 ) )
485 Image image = ResourceImage::New( imageName );
486 mPopupArrow.SetImage( image );
490 void Slider::ResizeProgressRegion( const Vector2& region )
494 mProgress.SetSize( region );
498 ImageActor Slider::CreateHandle()
500 ImageActor handle = ImageActor::New();
501 handle.SetRelayoutEnabled( false );
502 handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
503 handle.SetAnchorPoint( AnchorPoint::CENTER );
504 handle.SetZ( HANDLE_Z );
509 ImageActor Slider::CreatePopupArrow()
511 ImageActor arrow = ImageActor::New();
512 arrow.SetRelayoutEnabled( false );
513 arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
514 arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
515 arrow.SetZ( HANDLE_Z );
520 Toolkit::TextLabel Slider::CreatePopupText()
522 Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
523 textLabel.SetParentOrigin( ParentOrigin::CENTER );
524 textLabel.SetAnchorPoint( AnchorPoint::CENTER );
525 textLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
526 textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
527 textLabel.SetZ( VALUE_DISPLAY_TEXT_Z );
531 ImageActor Slider::CreatePopup()
533 ImageActor popup = ImageActor::New();
534 popup.SetRelayoutEnabled( false );
535 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
536 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
538 mValueTextLabel = CreatePopupText();
539 popup.Add( mValueTextLabel );
544 void Slider::SetHandleImageName( const std::string& imageName )
546 if( mHandle && ( imageName.size() > 0 ) )
548 Image image = ResourceImage::New( imageName );
549 mHandle.SetImage( image );
553 std::string Slider::GetHandleImageName()
557 return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
560 return std::string( "" );
563 void Slider::ResizeHandleRegion( const Vector2& region )
567 mHandle.SetSize( region );
571 void Slider::CreateHandleValueDisplay()
573 if( mHandle && !mHandleValueTextLabel )
575 mHandleValueTextLabel = Toolkit::TextLabel::New();
576 mHandleValueTextLabel.SetParentOrigin( ParentOrigin::CENTER );
577 mHandleValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER );
578 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
579 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
580 mHandleValueTextLabel.SetDrawMode( DrawMode::OVERLAY );
581 mHandle.Add( mHandleValueTextLabel );
585 void Slider::DestroyHandleValueDisplay()
587 UnparentAndReset(mHandleValueTextLabel);
590 void Slider::SetPopupTextColor( const Vector4& color )
592 mPopupTextColor = color;
595 Actor Slider::CreateValueDisplay()
597 Actor popup = Actor::New();
598 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
599 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
601 mPopupArrow = CreatePopupArrow();
602 popup.Add( mPopupArrow );
604 mPopup = CreatePopup();
605 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
606 mPopupArrow.Add( mPopup );
611 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
613 return mValueChangedSignal;
616 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
618 return mSlidingFinishedSignal;
621 Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
626 void Slider::UpdateSkin()
632 mBacking.SetColor( Color::WHITE );
633 mHandle.SetColor( Color::WHITE );
634 mProgress.SetColor( Color::WHITE );
639 Vector4 disableColor = GetDisableColor();
640 mBacking.SetColor( disableColor );
641 mHandle.SetColor( disableColor );
642 mProgress.SetColor( disableColor );
656 void Slider::CreateChildren()
661 mHitArea = CreateHitRegion();
662 mPanDetector = PanGestureDetector::New();
663 mPanDetector.Attach( mHitArea );
664 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
665 self.Add( mHitArea );
668 mBacking = CreateBacking();
669 self.Add( mBacking );
672 mProgress = CreateProgress();
673 mBacking.Add( mProgress );
676 mHandle = CreateHandle();
677 mBacking.Add( mHandle );
680 void Slider::SetHitRegion( const Vector2& size )
686 mHitArea.SetSize( mHitRegion );
690 const Vector2& Slider::GetHitRegion() const
695 void Slider::AddPopup()
699 mValueDisplay = CreateValueDisplay();
700 mValueDisplay.SetVisible( false );
701 mHandle.Add( mValueDisplay );
703 CreatePopupImage( GetPopupImageName() );
704 CreatePopupArrowImage( GetPopupArrowImageName() );
706 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
707 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
711 void Slider::RemovePopup()
718 mPopupArrow.Unparent();
721 mValueDisplay.Unparent();
722 mValueDisplay.Reset();
724 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
730 float Slider::MarkFilter( float value )
732 const float MARK_TOLERANCE = GetMarkTolerance();
735 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
737 const Property::Value& propertyValue = *it;
738 propertyValue.Get( mark );
739 mark = MapValuePercentage( mark );
741 // If close to a mark, return the mark
742 if( fabsf( mark - value ) < MARK_TOLERANCE )
751 float Slider::SnapToMark( float value )
753 float closestMark = value;
754 float closestDist = std::numeric_limits<float>::max();
757 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
759 const Property::Value& propertyValue = *it;
760 propertyValue.Get( mark );
761 mark = MapValuePercentage( mark );
763 float dist = fabsf( mark - value );
764 if( dist < closestDist )
774 bool Slider::MarkReached( float value, int& outIndex )
776 const float MARK_TOLERANCE = GetMarkTolerance();
780 tail = mMarks.size() - 1;
784 while( head <= tail )
786 current = head + ( tail - head ) / 2;
788 const Property::Value& propertyValue = mMarks[ current ];
789 propertyValue.Get( mark );
790 mark = MapValuePercentage( mark );
792 if( fabsf( mark - value ) < MARK_TOLERANCE )
811 bool Slider::HideValueView()
815 mValueDisplay.SetVisible( false );
821 void Slider::SetLowerBound( float bound )
824 DisplayValue( GetValue(), false );
827 float Slider::GetLowerBound() const
832 void Slider::SetUpperBound( float bound )
835 DisplayValue( GetValue(), false );
838 float Slider::GetUpperBound() const
843 void Slider::SetValue( float value )
846 DisplayValue( mValue, true );
849 float Slider::GetValue() const
854 void Slider::SetBackingRegion( const Vector2& region )
856 mBackingRegion = region;
860 mBacking.SetSize( mBackingRegion );
863 ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
865 mDomain = CalcDomain( mBackingRegion );
867 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
870 const Vector2& Slider::GetBackingRegion() const
872 return mBackingRegion;
875 void Slider::SetHandleRegion( const Vector2& region )
877 mHandleRegionSize = region;
879 ResizeHandleRegion( mHandleRegionSize );
881 Vector2 hitRegion = GetHitRegion();
882 hitRegion.x += mHandleRegionSize.x;
883 SetHitRegion( hitRegion );
886 const Vector2& Slider::GetHandleRegion() const
888 return mHandleRegionSize;
891 void Slider::SetDisableColor( const Vector4& color )
893 mDisableColor = color;
898 Vector4 Slider::GetDisableColor() const
900 return mDisableColor;
903 Vector4 Slider::GetPopupTextColor() const
905 return mPopupTextColor;
908 void Slider::SetValuePrecision( int precision )
910 mValuePrecision = precision;
913 int Slider::GetValuePrecision() const
915 return mValuePrecision;
918 void Slider::SetShowPopup( bool showPopup )
920 mShowPopup = showPopup;
933 bool Slider::GetShowPopup() const
938 void Slider::SetShowValue( bool showValue )
940 mShowValue = showValue;
944 CreateHandleValueDisplay();
948 DestroyHandleValueDisplay();
952 bool Slider::GetShowValue() const
957 void Slider::SetEnabled( bool enabled )
971 bool Slider::IsEnabled() const
973 return mState != DISABLED;
976 void Slider::SetMarkTolerance( float tolerance )
978 mMarkTolerance = tolerance;
981 float Slider::GetMarkTolerance() const
983 return mMarkTolerance;
986 // Static class method to support script connecting signals
987 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
989 Dali::BaseHandle handle( object );
991 bool connected = true;
992 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
994 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
996 slider.ValueChangedSignal().Connect( tracker, functor );
998 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
1000 slider.MarkSignal().Connect( tracker, functor );
1004 // signalName does not match any signal
1011 void Slider::DisplayPopup( float value )
1013 // Value displayDoConnectSignal
1014 if( mValueTextLabel )
1016 std::stringstream ss;
1017 ss.precision( GetValuePrecision() );
1018 ss << std::fixed << value;
1019 mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
1023 mValueDisplay.SetVisible( true );
1025 mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1030 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1032 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1036 Slider& sliderImpl( GetImpl( slider ) );
1038 switch ( propertyIndex )
1040 case Toolkit::Slider::Property::LOWER_BOUND:
1042 sliderImpl.SetLowerBound( value.Get< float >() );
1046 case Toolkit::Slider::Property::UPPER_BOUND:
1048 sliderImpl.SetUpperBound( value.Get< float >() );
1052 case Toolkit::Slider::Property::VALUE:
1054 sliderImpl.SetValue( value.Get< float >() );
1058 case Toolkit::Slider::Property::HIT_REGION:
1060 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1064 case Toolkit::Slider::Property::BACKING_REGION:
1066 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1070 case Toolkit::Slider::Property::HANDLE_REGION:
1072 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1076 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1078 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1082 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1084 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1088 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1090 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1094 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1096 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1100 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1102 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1106 case Toolkit::Slider::Property::DISABLE_COLOR:
1108 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1112 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1114 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1118 case Toolkit::Slider::Property::VALUE_PRECISION:
1120 sliderImpl.SetValuePrecision( value.Get< int >() );
1124 case Toolkit::Slider::Property::SHOW_POPUP:
1126 sliderImpl.SetShowPopup( value.Get< bool >() );
1130 case Toolkit::Slider::Property::SHOW_VALUE:
1132 sliderImpl.SetShowValue( value.Get< bool >() );
1136 case Toolkit::Slider::Property::ENABLED:
1138 sliderImpl.SetEnabled( value.Get< bool >() );
1142 case Toolkit::Slider::Property::MARKS:
1144 sliderImpl.SetMarks( value.Get< Property::Array >() );
1148 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1150 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1154 case Toolkit::Slider::Property::MARK_TOLERANCE:
1156 sliderImpl.SetMarkTolerance( value.Get< float >() );
1163 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1165 Property::Value value;
1167 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1171 Slider& sliderImpl( GetImpl( slider ) );
1173 switch ( propertyIndex )
1175 case Toolkit::Slider::Property::LOWER_BOUND:
1177 value = sliderImpl.GetLowerBound();
1181 case Toolkit::Slider::Property::UPPER_BOUND:
1183 value = sliderImpl.GetUpperBound();
1187 case Toolkit::Slider::Property::VALUE:
1189 value = sliderImpl.GetValue();
1193 case Toolkit::Slider::Property::HIT_REGION:
1195 value = sliderImpl.GetHitRegion();
1199 case Toolkit::Slider::Property::BACKING_REGION:
1201 value = sliderImpl.GetBackingRegion();
1205 case Toolkit::Slider::Property::HANDLE_REGION:
1207 value = sliderImpl.GetHandleRegion();
1211 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1213 value = sliderImpl.GetBackingImageName();
1217 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1219 value = sliderImpl.GetHandleImageName();
1223 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1225 value = sliderImpl.GetProgressImageName();
1229 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1231 value = sliderImpl.GetPopupImageName();
1235 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1237 value = sliderImpl.GetPopupArrowImageName();
1241 case Toolkit::Slider::Property::DISABLE_COLOR:
1243 value = sliderImpl.GetDisableColor();
1247 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1249 value = sliderImpl.GetPopupTextColor();
1253 case Toolkit::Slider::Property::VALUE_PRECISION:
1255 value = sliderImpl.GetValuePrecision();
1259 case Toolkit::Slider::Property::SHOW_POPUP:
1261 value = sliderImpl.GetShowPopup();
1265 case Toolkit::Slider::Property::SHOW_VALUE:
1267 value = sliderImpl.GetShowValue();
1271 case Toolkit::Slider::Property::ENABLED:
1273 value = sliderImpl.IsEnabled();
1277 case Toolkit::Slider::Property::MARKS:
1279 // TODO: Need to be able to return a PropertyArray
1280 // value = sliderImpl.GetMarks();
1284 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1286 value = sliderImpl.GetSnapToMarks();
1290 case Toolkit::Slider::Property::MARK_TOLERANCE:
1292 value = sliderImpl.GetMarkTolerance();
1301 } // namespace Internal
1303 } // namespace Toolkit