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.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
532 textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
533 textLabel.SetZ( VALUE_DISPLAY_TEXT_Z );
537 ImageActor Slider::CreatePopup()
539 ImageActor popup = ImageActor::New();
540 popup.SetRelayoutEnabled( false );
541 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
542 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
544 mValueTextLabel = CreatePopupText();
545 popup.Add( mValueTextLabel );
550 void Slider::SetHandleImageName( const std::string& imageName )
552 if( mHandle && ( imageName.size() > 0 ) )
554 Image image = ResourceImage::New( imageName );
555 mHandle.SetImage( image );
559 std::string Slider::GetHandleImageName()
563 return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
566 return std::string( "" );
569 void Slider::ResizeHandleRegion( const Vector2& region )
573 mHandle.SetSize( region );
577 void Slider::CreateHandleValueDisplay()
579 if( mHandle && !mHandleValueTextLabel )
581 mHandleValueTextLabel = Toolkit::TextLabel::New();
582 mHandleValueTextLabel.SetParentOrigin( ParentOrigin::CENTER );
583 mHandleValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER );
584 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
585 mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
586 mHandleValueTextLabel.SetDrawMode( DrawMode::OVERLAY );
587 mHandle.Add( mHandleValueTextLabel );
591 void Slider::DestroyHandleValueDisplay()
593 UnparentAndReset(mHandleValueTextLabel);
596 void Slider::SetPopupTextColor( const Vector4& color )
598 mPopupTextColor = color;
601 Actor Slider::CreateValueDisplay()
603 Actor popup = Actor::New();
604 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
605 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
607 mPopupArrow = CreatePopupArrow();
608 popup.Add( mPopupArrow );
610 mPopup = CreatePopup();
611 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
612 mPopupArrow.Add( mPopup );
617 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
619 return mValueChangedSignal;
622 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
624 return mSlidingFinishedSignal;
627 Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
632 void Slider::UpdateSkin()
638 mBacking.SetColor( Color::WHITE );
639 mHandle.SetColor( Color::WHITE );
640 mProgress.SetColor( Color::WHITE );
645 Vector4 disableColor = GetDisableColor();
646 mBacking.SetColor( disableColor );
647 mHandle.SetColor( disableColor );
648 mProgress.SetColor( disableColor );
662 void Slider::CreateChildren()
667 mHitArea = CreateHitRegion();
668 mPanDetector = PanGestureDetector::New();
669 mPanDetector.Attach( mHitArea );
670 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
671 self.Add( mHitArea );
674 mBacking = CreateBacking();
675 self.Add( mBacking );
678 mProgress = CreateProgress();
679 mBacking.Add( mProgress );
682 mHandle = CreateHandle();
683 mBacking.Add( mHandle );
686 void Slider::SetHitRegion( const Vector2& size )
692 mHitArea.SetSize( mHitRegion );
696 const Vector2& Slider::GetHitRegion() const
701 void Slider::AddPopup()
705 mValueDisplay = CreateValueDisplay();
706 mValueDisplay.SetVisible( false );
707 mHandle.Add( mValueDisplay );
709 CreatePopupImage( GetPopupImageName() );
710 CreatePopupArrowImage( GetPopupArrowImageName() );
712 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
713 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
717 void Slider::RemovePopup()
724 mPopupArrow.Unparent();
727 mValueDisplay.Unparent();
728 mValueDisplay.Reset();
730 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
736 float Slider::MarkFilter( float value )
738 const float MARK_TOLERANCE = GetMarkTolerance();
741 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
743 const Property::Value& propertyValue = *it;
744 propertyValue.Get( mark );
745 mark = MapValuePercentage( mark );
747 // If close to a mark, return the mark
748 if( fabsf( mark - value ) < MARK_TOLERANCE )
757 float Slider::SnapToMark( float value )
759 float closestMark = value;
760 float closestDist = std::numeric_limits<float>::max();
763 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
765 const Property::Value& propertyValue = *it;
766 propertyValue.Get( mark );
767 mark = MapValuePercentage( mark );
769 float dist = fabsf( mark - value );
770 if( dist < closestDist )
780 bool Slider::MarkReached( float value, int& outIndex )
782 const float MARK_TOLERANCE = GetMarkTolerance();
786 tail = mMarks.size() - 1;
790 while( head <= tail )
792 current = head + ( tail - head ) / 2;
794 const Property::Value& propertyValue = mMarks[ current ];
795 propertyValue.Get( mark );
796 mark = MapValuePercentage( mark );
798 if( fabsf( mark - value ) < MARK_TOLERANCE )
817 bool Slider::HideValueView()
821 mValueDisplay.SetVisible( false );
827 void Slider::SetLowerBound( float bound )
830 DisplayValue( GetValue(), false );
833 float Slider::GetLowerBound() const
838 void Slider::SetUpperBound( float bound )
841 DisplayValue( GetValue(), false );
844 float Slider::GetUpperBound() const
849 void Slider::SetValue( float value )
852 DisplayValue( mValue, true );
855 float Slider::GetValue() const
860 void Slider::SetBackingRegion( const Vector2& region )
862 mBackingRegion = region;
866 mBacking.SetSize( mBackingRegion );
869 ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
871 mDomain = CalcDomain( mBackingRegion );
873 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
876 const Vector2& Slider::GetBackingRegion() const
878 return mBackingRegion;
881 void Slider::SetHandleRegion( const Vector2& region )
883 mHandleRegionSize = region;
885 ResizeHandleRegion( mHandleRegionSize );
887 Vector2 hitRegion = GetHitRegion();
888 hitRegion.x += mHandleRegionSize.x;
889 SetHitRegion( hitRegion );
892 const Vector2& Slider::GetHandleRegion() const
894 return mHandleRegionSize;
897 void Slider::SetDisableColor( const Vector4& color )
899 mDisableColor = color;
904 Vector4 Slider::GetDisableColor() const
906 return mDisableColor;
909 Vector4 Slider::GetPopupTextColor() const
911 return mPopupTextColor;
914 void Slider::SetValuePrecision( int precision )
916 mValuePrecision = precision;
919 int Slider::GetValuePrecision() const
921 return mValuePrecision;
924 void Slider::SetShowPopup( bool showPopup )
926 mShowPopup = showPopup;
939 bool Slider::GetShowPopup() const
944 void Slider::SetShowValue( bool showValue )
946 mShowValue = showValue;
950 CreateHandleValueDisplay();
954 DestroyHandleValueDisplay();
958 bool Slider::GetShowValue() const
963 void Slider::SetEnabled( bool enabled )
977 bool Slider::IsEnabled() const
979 return mState != DISABLED;
982 void Slider::SetMarkTolerance( float tolerance )
984 mMarkTolerance = tolerance;
987 float Slider::GetMarkTolerance() const
989 return mMarkTolerance;
992 // Static class method to support script connecting signals
993 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
995 Dali::BaseHandle handle( object );
997 bool connected = true;
998 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
1000 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
1002 slider.ValueChangedSignal().Connect( tracker, functor );
1004 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
1006 slider.MarkSignal().Connect( tracker, functor );
1010 // signalName does not match any signal
1017 void Slider::DisplayPopup( float value )
1019 // Value displayDoConnectSignal
1020 if( mValueTextLabel )
1022 std::stringstream ss;
1023 ss.precision( GetValuePrecision() );
1024 ss << std::fixed << value;
1025 mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
1029 mValueDisplay.SetVisible( true );
1031 mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1036 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1038 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1042 Slider& sliderImpl( GetImpl( slider ) );
1044 switch ( propertyIndex )
1046 case Toolkit::Slider::Property::LOWER_BOUND:
1048 sliderImpl.SetLowerBound( value.Get< float >() );
1052 case Toolkit::Slider::Property::UPPER_BOUND:
1054 sliderImpl.SetUpperBound( value.Get< float >() );
1058 case Toolkit::Slider::Property::VALUE:
1060 sliderImpl.SetValue( value.Get< float >() );
1064 case Toolkit::Slider::Property::HIT_REGION:
1066 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1070 case Toolkit::Slider::Property::BACKING_REGION:
1072 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1076 case Toolkit::Slider::Property::HANDLE_REGION:
1078 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1082 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1084 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1088 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1090 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1094 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1096 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1100 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1102 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1106 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1108 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1112 case Toolkit::Slider::Property::DISABLE_COLOR:
1114 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1118 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1120 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1124 case Toolkit::Slider::Property::VALUE_PRECISION:
1126 sliderImpl.SetValuePrecision( value.Get< int >() );
1130 case Toolkit::Slider::Property::SHOW_POPUP:
1132 sliderImpl.SetShowPopup( value.Get< bool >() );
1136 case Toolkit::Slider::Property::SHOW_VALUE:
1138 sliderImpl.SetShowValue( value.Get< bool >() );
1142 case Toolkit::Slider::Property::ENABLED:
1144 sliderImpl.SetEnabled( value.Get< bool >() );
1148 case Toolkit::Slider::Property::MARKS:
1150 sliderImpl.SetMarks( value.Get< Property::Array >() );
1154 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1156 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1160 case Toolkit::Slider::Property::MARK_TOLERANCE:
1162 sliderImpl.SetMarkTolerance( value.Get< float >() );
1169 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1171 Property::Value value;
1173 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1177 Slider& sliderImpl( GetImpl( slider ) );
1179 switch ( propertyIndex )
1181 case Toolkit::Slider::Property::LOWER_BOUND:
1183 value = sliderImpl.GetLowerBound();
1187 case Toolkit::Slider::Property::UPPER_BOUND:
1189 value = sliderImpl.GetUpperBound();
1193 case Toolkit::Slider::Property::VALUE:
1195 value = sliderImpl.GetValue();
1199 case Toolkit::Slider::Property::HIT_REGION:
1201 value = sliderImpl.GetHitRegion();
1205 case Toolkit::Slider::Property::BACKING_REGION:
1207 value = sliderImpl.GetBackingRegion();
1211 case Toolkit::Slider::Property::HANDLE_REGION:
1213 value = sliderImpl.GetHandleRegion();
1217 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1219 value = sliderImpl.GetBackingImageName();
1223 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1225 value = sliderImpl.GetHandleImageName();
1229 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1231 value = sliderImpl.GetProgressImageName();
1235 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1237 value = sliderImpl.GetPopupImageName();
1241 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1243 value = sliderImpl.GetPopupArrowImageName();
1247 case Toolkit::Slider::Property::DISABLE_COLOR:
1249 value = sliderImpl.GetDisableColor();
1253 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1255 value = sliderImpl.GetPopupTextColor();
1259 case Toolkit::Slider::Property::VALUE_PRECISION:
1261 value = sliderImpl.GetValuePrecision();
1265 case Toolkit::Slider::Property::SHOW_POPUP:
1267 value = sliderImpl.GetShowPopup();
1271 case Toolkit::Slider::Property::SHOW_VALUE:
1273 value = sliderImpl.GetShowValue();
1277 case Toolkit::Slider::Property::ENABLED:
1279 value = sliderImpl.IsEnabled();
1283 case Toolkit::Slider::Property::MARKS:
1285 // TODO: Need to be able to return a PropertyArray
1286 // value = sliderImpl.GetMarks();
1290 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1292 value = sliderImpl.GetSnapToMarks();
1296 case Toolkit::Slider::Property::MARK_TOLERANCE:
1298 value = sliderImpl.GetMarkTolerance();
1307 } // namespace Internal
1309 } // namespace Toolkit