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( mHandleValueTextView )
353 std::stringstream ss;
354 ss.precision( GetValuePrecision() );
355 ss << std::fixed << clampledValue;
357 mHandleValueTextView.SetText( 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::TextView Slider::CreatePopupText()
528 Toolkit::TextView textView = Toolkit::TextView::New();
529 textView.SetParentOrigin( ParentOrigin::CENTER );
530 textView.SetAnchorPoint( AnchorPoint::CENTER );
531 textView.SetZ( VALUE_DISPLAY_TEXT_Z );
535 ImageActor Slider::CreatePopup()
537 ImageActor popup = ImageActor::New();
538 popup.SetRelayoutEnabled( false );
539 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
540 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
542 mValueTextView = CreatePopupText();
543 popup.Add( mValueTextView );
548 void Slider::SetHandleImageName( const std::string& imageName )
550 if( mHandle && ( imageName.size() > 0 ) )
552 Image image = ResourceImage::New( imageName );
553 mHandle.SetImage( image );
557 std::string Slider::GetHandleImageName()
561 return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
564 return std::string( "" );
567 void Slider::ResizeHandleRegion( const Vector2& region )
571 mHandle.SetSize( region );
575 void Slider::CreateHandleValueDisplay()
577 if( mHandle && !mHandleValueTextView )
579 mHandleValueTextView = Toolkit::TextView::New();
580 mHandleValueTextView.SetParentOrigin( ParentOrigin::CENTER );
581 mHandleValueTextView.SetAnchorPoint( AnchorPoint::CENTER );
582 mHandleValueTextView.SetSize( GetHandleRegion() );
583 mHandleValueTextView.SetZ( HANDLE_VALUE_DISPLAY_TEXT_Z );
584 mHandle.Add( mHandleValueTextView );
588 void Slider::DestroyHandleValueDisplay()
590 if(mHandleValueTextView)
592 mHandleValueTextView.Unparent();
593 mHandleValueTextView.Reset();
597 void Slider::SetPopupTextColor( const Vector4& color )
599 mPopupTextColor = color;
602 Actor Slider::CreateValueDisplay()
604 Actor popup = Actor::New();
605 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
606 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
608 mPopupArrow = CreatePopupArrow();
609 popup.Add( mPopupArrow );
611 mPopup = CreatePopup();
612 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
613 mPopupArrow.Add( mPopup );
618 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
620 return mValueChangedSignal;
623 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
625 return mSlidingFinishedSignal;
628 Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
633 void Slider::UpdateSkin()
639 mBacking.SetColor( Color::WHITE );
640 mHandle.SetColor( Color::WHITE );
641 mProgress.SetColor( Color::WHITE );
646 Vector4 disableColor = GetDisableColor();
647 mBacking.SetColor( disableColor );
648 mHandle.SetColor( disableColor );
649 mProgress.SetColor( disableColor );
663 void Slider::CreateChildren()
668 mHitArea = CreateHitRegion();
669 mPanDetector = PanGestureDetector::New();
670 mPanDetector.Attach( mHitArea );
671 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
672 self.Add( mHitArea );
675 mBacking = CreateBacking();
676 self.Add( mBacking );
679 mProgress = CreateProgress();
680 mBacking.Add( mProgress );
683 mHandle = CreateHandle();
684 mBacking.Add( mHandle );
687 void Slider::SetHitRegion( const Vector2& size )
693 mHitArea.SetSize( mHitRegion );
697 const Vector2& Slider::GetHitRegion() const
702 void Slider::AddPopup()
706 mValueDisplay = CreateValueDisplay();
707 mValueDisplay.SetVisible( false );
708 mHandle.Add( mValueDisplay );
710 CreatePopupImage( GetPopupImageName() );
711 CreatePopupArrowImage( GetPopupArrowImageName() );
713 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
714 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
718 void Slider::RemovePopup()
725 mPopupArrow.Unparent();
728 mValueDisplay.Unparent();
729 mValueDisplay.Reset();
731 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
737 float Slider::MarkFilter( float value )
739 const float MARK_TOLERANCE = GetMarkTolerance();
742 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
744 const Property::Value& propertyValue = *it;
745 propertyValue.Get( mark );
746 mark = MapValuePercentage( mark );
748 // If close to a mark, return the mark
749 if( fabsf( mark - value ) < MARK_TOLERANCE )
758 float Slider::SnapToMark( float value )
760 float closestMark = value;
761 float closestDist = std::numeric_limits<float>::max();
764 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
766 const Property::Value& propertyValue = *it;
767 propertyValue.Get( mark );
768 mark = MapValuePercentage( mark );
770 float dist = fabsf( mark - value );
771 if( dist < closestDist )
781 bool Slider::MarkReached( float value, int& outIndex )
783 const float MARK_TOLERANCE = GetMarkTolerance();
787 tail = mMarks.size() - 1;
791 while( head <= tail )
793 current = head + ( tail - head ) / 2;
795 const Property::Value& propertyValue = mMarks[ current ];
796 propertyValue.Get( mark );
797 mark = MapValuePercentage( mark );
799 if( fabsf( mark - value ) < MARK_TOLERANCE )
818 bool Slider::HideValueView()
822 mValueDisplay.SetVisible( false );
828 void Slider::SetLowerBound( float bound )
831 DisplayValue( GetValue(), false );
834 float Slider::GetLowerBound() const
839 void Slider::SetUpperBound( float bound )
842 DisplayValue( GetValue(), false );
845 float Slider::GetUpperBound() const
850 void Slider::SetValue( float value )
853 DisplayValue( mValue, true );
856 float Slider::GetValue() const
861 void Slider::SetBackingRegion( const Vector2& region )
863 mBackingRegion = region;
867 mBacking.SetSize( mBackingRegion );
870 ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
872 mDomain = CalcDomain( mBackingRegion );
874 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
877 const Vector2& Slider::GetBackingRegion() const
879 return mBackingRegion;
882 void Slider::SetHandleRegion( const Vector2& region )
884 mHandleRegionSize = region;
886 ResizeHandleRegion( mHandleRegionSize );
888 Vector2 hitRegion = GetHitRegion();
889 hitRegion.x += mHandleRegionSize.x;
890 SetHitRegion( hitRegion );
893 const Vector2& Slider::GetHandleRegion() const
895 return mHandleRegionSize;
898 void Slider::SetDisableColor( const Vector4& color )
900 mDisableColor = color;
905 Vector4 Slider::GetDisableColor() const
907 return mDisableColor;
910 Vector4 Slider::GetPopupTextColor() const
912 return mPopupTextColor;
915 void Slider::SetValuePrecision( int precision )
917 mValuePrecision = precision;
920 int Slider::GetValuePrecision() const
922 return mValuePrecision;
925 void Slider::SetShowPopup( bool showPopup )
927 mShowPopup = showPopup;
940 bool Slider::GetShowPopup() const
945 void Slider::SetShowValue( bool showValue )
947 mShowValue = showValue;
951 CreateHandleValueDisplay();
955 DestroyHandleValueDisplay();
959 bool Slider::GetShowValue() const
964 void Slider::SetEnabled( bool enabled )
978 bool Slider::IsEnabled() const
980 return mState != DISABLED;
983 void Slider::SetMarkTolerance( float tolerance )
985 mMarkTolerance = tolerance;
988 float Slider::GetMarkTolerance() const
990 return mMarkTolerance;
993 // Static class method to support script connecting signals
994 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
996 Dali::BaseHandle handle( object );
998 bool connected = true;
999 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
1001 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
1003 slider.ValueChangedSignal().Connect( tracker, functor );
1005 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
1007 slider.MarkSignal().Connect( tracker, functor );
1011 // signalName does not match any signal
1018 void Slider::DisplayPopup( float value )
1020 // Value displayDoConnectSignal
1021 if( mValueTextView )
1023 std::stringstream ss;
1024 ss.precision( GetValuePrecision() );
1025 ss << std::fixed << value;
1026 mValueTextView.SetText( ss.str() );
1028 style.SetTextColor( GetPopupTextColor() );
1029 mValueTextView.SetStyleToCurrentText( style, TextStyle::COLOR);
1033 Font font = Font::New();
1034 float popupWidth = font.MeasureText( ss.str() ).x + VALUE_POPUP_MARGIN * 2.0f;
1035 if( popupWidth < VALUE_POPUP_MIN_WIDTH )
1037 popupWidth = VALUE_POPUP_MIN_WIDTH;
1040 mPopup.SetSize( popupWidth, VALUE_POPUP_HEIGHT );
1041 mValueDisplay.SetVisible( true );
1043 mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1048 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1050 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1054 Slider& sliderImpl( GetImpl( slider ) );
1056 switch ( propertyIndex )
1058 case Toolkit::Slider::Property::LOWER_BOUND:
1060 sliderImpl.SetLowerBound( value.Get< float >() );
1064 case Toolkit::Slider::Property::UPPER_BOUND:
1066 sliderImpl.SetUpperBound( value.Get< float >() );
1070 case Toolkit::Slider::Property::VALUE:
1072 sliderImpl.SetValue( value.Get< float >() );
1076 case Toolkit::Slider::Property::HIT_REGION:
1078 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1082 case Toolkit::Slider::Property::BACKING_REGION:
1084 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1088 case Toolkit::Slider::Property::HANDLE_REGION:
1090 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1094 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1096 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1100 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1102 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1106 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1108 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1112 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1114 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1118 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1120 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1124 case Toolkit::Slider::Property::DISABLE_COLOR:
1126 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1130 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1132 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1136 case Toolkit::Slider::Property::VALUE_PRECISION:
1138 sliderImpl.SetValuePrecision( value.Get< int >() );
1142 case Toolkit::Slider::Property::SHOW_POPUP:
1144 sliderImpl.SetShowPopup( value.Get< bool >() );
1148 case Toolkit::Slider::Property::SHOW_VALUE:
1150 sliderImpl.SetShowValue( value.Get< bool >() );
1154 case Toolkit::Slider::Property::ENABLED:
1156 sliderImpl.SetEnabled( value.Get< bool >() );
1160 case Toolkit::Slider::Property::MARKS:
1162 sliderImpl.SetMarks( value.Get< Property::Array >() );
1166 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1168 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1172 case Toolkit::Slider::Property::MARK_TOLERANCE:
1174 sliderImpl.SetMarkTolerance( value.Get< float >() );
1181 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1183 Property::Value value;
1185 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1189 Slider& sliderImpl( GetImpl( slider ) );
1191 switch ( propertyIndex )
1193 case Toolkit::Slider::Property::LOWER_BOUND:
1195 value = sliderImpl.GetLowerBound();
1199 case Toolkit::Slider::Property::UPPER_BOUND:
1201 value = sliderImpl.GetUpperBound();
1205 case Toolkit::Slider::Property::VALUE:
1207 value = sliderImpl.GetValue();
1211 case Toolkit::Slider::Property::HIT_REGION:
1213 value = sliderImpl.GetHitRegion();
1217 case Toolkit::Slider::Property::BACKING_REGION:
1219 value = sliderImpl.GetBackingRegion();
1223 case Toolkit::Slider::Property::HANDLE_REGION:
1225 value = sliderImpl.GetHandleRegion();
1229 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1231 value = sliderImpl.GetBackingImageName();
1235 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1237 value = sliderImpl.GetHandleImageName();
1241 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1243 value = sliderImpl.GetProgressImageName();
1247 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1249 value = sliderImpl.GetPopupImageName();
1253 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1255 value = sliderImpl.GetPopupArrowImageName();
1259 case Toolkit::Slider::Property::DISABLE_COLOR:
1261 value = sliderImpl.GetDisableColor();
1265 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1267 value = sliderImpl.GetPopupTextColor();
1271 case Toolkit::Slider::Property::VALUE_PRECISION:
1273 value = sliderImpl.GetValuePrecision();
1277 case Toolkit::Slider::Property::SHOW_POPUP:
1279 value = sliderImpl.GetShowPopup();
1283 case Toolkit::Slider::Property::SHOW_VALUE:
1285 value = sliderImpl.GetShowValue();
1289 case Toolkit::Slider::Property::ENABLED:
1291 value = sliderImpl.IsEnabled();
1295 case Toolkit::Slider::Property::MARKS:
1297 // TODO: Need to be able to return a PropertyArray
1298 // value = sliderImpl.GetMarks();
1302 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1304 value = sliderImpl.GetSnapToMarks();
1308 case Toolkit::Slider::Property::MARK_TOLERANCE:
1310 value = sliderImpl.GetMarkTolerance();
1319 } // namespace Internal
1321 } // namespace Toolkit