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;
356 mHandleValueTextView.SetText( ss.str() );
360 void Slider::SetMarks( const MarkList& marks )
363 for( MarkList::const_iterator it = marks.begin(), itEnd = marks.end(); it != itEnd; ++it )
365 const Property::Value& propertyValue = *it;
366 propertyValue.Get( value );
368 mMarks.push_back( value );
372 const Slider::MarkList& Slider::GetMarks() const
377 void Slider::SetSnapToMarks( bool snap )
382 bool Slider::GetSnapToMarks() const
387 Actor Slider::CreateHitRegion()
389 Actor hitRegion = Actor::New();
390 hitRegion.SetParentOrigin( ParentOrigin::CENTER );
391 hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
392 hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
397 ImageActor Slider::CreateBacking()
399 ImageActor backing = ImageActor::New();
400 backing.SetParentOrigin( ParentOrigin::CENTER );
401 backing.SetAnchorPoint( AnchorPoint::CENTER );
402 backing.SetZ( BACKING_Z );
407 void Slider::SetBackingImageName( const std::string& imageName )
409 if( mBacking && ( imageName.size() > 0 ) )
411 Image image = ResourceImage::New( imageName );
412 mBacking.SetImage( image );
416 std::string Slider::GetBackingImageName()
420 return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
423 return std::string( "" );
426 ImageActor Slider::CreateProgress()
428 ImageActor progress = ImageActor::New();
429 progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
430 progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
431 progress.SetZ( PROGRESS_Z );
436 void Slider::SetProgressImageName( const std::string& imageName )
438 if( mProgress && ( imageName.size() > 0 ) )
440 Image image = ResourceImage::New( imageName );
441 mProgress.SetImage( image );
445 std::string Slider::GetProgressImageName()
449 return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
452 return std::string( "" );
455 void Slider::SetPopupImageName( const std::string& imageName )
457 mPopupImageName = imageName;
460 std::string Slider::GetPopupImageName()
462 return mPopupImageName;
465 void Slider::CreatePopupImage( const std::string& imageName )
467 if( mPopup && ( imageName.size() > 0 ) )
469 Image image = ResourceImage::New( imageName );
470 mPopup.SetImage( image );
474 void Slider::SetPopupArrowImageName( const std::string& imageName )
476 mPopupArrowImageName = imageName;
479 std::string Slider::GetPopupArrowImageName()
481 return mPopupArrowImageName;
484 void Slider::CreatePopupArrowImage( const std::string& imageName )
486 if( mPopupArrow && ( imageName.size() > 0 ) )
488 Image image = ResourceImage::New( imageName );
489 mPopupArrow.SetImage( image );
493 void Slider::ResizeProgressRegion( const Vector2& region )
497 mProgress.SetSize( region );
501 ImageActor Slider::CreateHandle()
503 ImageActor handle = ImageActor::New();
504 handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
505 handle.SetAnchorPoint( AnchorPoint::CENTER );
506 handle.SetZ( HANDLE_Z );
511 ImageActor Slider::CreatePopupArrow()
513 ImageActor arrow = ImageActor::New();
514 arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
515 arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
516 arrow.SetZ( HANDLE_Z );
521 Toolkit::TextView Slider::CreatePopupText()
523 Toolkit::TextView textView = Toolkit::TextView::New();
524 textView.SetParentOrigin( ParentOrigin::CENTER );
525 textView.SetAnchorPoint( AnchorPoint::CENTER );
526 textView.SetSizePolicy( Toolkit::Control::Flexible, Toolkit::Control::Flexible );
527 textView.SetZ( VALUE_DISPLAY_TEXT_Z );
531 ImageActor Slider::CreatePopup()
533 ImageActor popup = ImageActor::New();
534 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
535 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
537 mValueTextView = CreatePopupText();
538 popup.Add( mValueTextView );
543 void Slider::SetHandleImageName( const std::string& imageName )
545 if( mHandle && ( imageName.size() > 0 ) )
547 Image image = ResourceImage::New( imageName );
548 mHandle.SetImage( image );
552 std::string Slider::GetHandleImageName()
556 return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
559 return std::string( "" );
562 void Slider::ResizeHandleRegion( const Vector2& region )
566 mHandle.SetSize( region );
570 void Slider::CreateHandleValueDisplay()
572 if( mHandle && !mHandleValueTextView )
574 mHandleValueTextView = Toolkit::TextView::New();
575 mHandleValueTextView.SetParentOrigin( ParentOrigin::CENTER );
576 mHandleValueTextView.SetAnchorPoint( AnchorPoint::CENTER );
577 mHandleValueTextView.SetSize( GetHandleRegion() );
578 mHandleValueTextView.SetZ( HANDLE_VALUE_DISPLAY_TEXT_Z );
579 mHandle.Add( mHandleValueTextView );
583 void Slider::DestroyHandleValueDisplay()
585 if(mHandleValueTextView)
587 mHandleValueTextView.Unparent();
588 mHandleValueTextView.Reset();
592 void Slider::SetPopupTextColor( const Vector4& color )
594 mPopupTextColor = color;
597 Actor Slider::CreateValueDisplay()
599 Actor popup = Actor::New();
600 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
601 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
603 mPopupArrow = CreatePopupArrow();
604 popup.Add( mPopupArrow );
606 mPopup = CreatePopup();
607 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
608 mPopupArrow.Add( mPopup );
613 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
615 return mValueChangedSignal;
618 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
620 return mSlidingFinishedSignal;
623 Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
628 void Slider::UpdateSkin()
634 mBacking.SetColor( Color::WHITE );
635 mHandle.SetColor( Color::WHITE );
636 mProgress.SetColor( Color::WHITE );
641 Vector4 disableColor = GetDisableColor();
642 mBacking.SetColor( disableColor );
643 mHandle.SetColor( disableColor );
644 mProgress.SetColor( disableColor );
658 void Slider::CreateChildren()
663 mHitArea = CreateHitRegion();
664 mPanDetector = PanGestureDetector::New();
665 mPanDetector.Attach( mHitArea );
666 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
667 self.Add( mHitArea );
670 mBacking = CreateBacking();
671 self.Add( mBacking );
674 mProgress = CreateProgress();
675 mBacking.Add( mProgress );
678 mHandle = CreateHandle();
679 mBacking.Add( mHandle );
682 void Slider::SetHitRegion( const Vector2& size )
688 mHitArea.SetSize( mHitRegion );
692 const Vector2& Slider::GetHitRegion() const
697 void Slider::AddPopup()
701 mValueDisplay = CreateValueDisplay();
702 mValueDisplay.SetVisible( false );
703 mHandle.Add( mValueDisplay );
705 CreatePopupImage( GetPopupImageName() );
706 CreatePopupArrowImage( GetPopupArrowImageName() );
708 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
709 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
713 void Slider::RemovePopup()
720 mPopupArrow.Unparent();
723 mValueDisplay.Unparent();
724 mValueDisplay.Reset();
726 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
732 float Slider::MarkFilter( float value )
734 const float MARK_TOLERANCE = GetMarkTolerance();
737 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
739 const Property::Value& propertyValue = *it;
740 propertyValue.Get( mark );
741 mark = MapValuePercentage( mark );
743 // If close to a mark, return the mark
744 if( fabsf( mark - value ) < MARK_TOLERANCE )
753 float Slider::SnapToMark( float value )
755 float closestMark = value;
756 float closestDist = std::numeric_limits<float>::max();
759 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
761 const Property::Value& propertyValue = *it;
762 propertyValue.Get( mark );
763 mark = MapValuePercentage( mark );
765 float dist = fabsf( mark - value );
766 if( dist < closestDist )
776 bool Slider::MarkReached( float value, int& outIndex )
778 const float MARK_TOLERANCE = GetMarkTolerance();
782 tail = mMarks.size() - 1;
786 while( head <= tail )
788 current = head + ( tail - head ) / 2;
790 const Property::Value& propertyValue = mMarks[ current ];
791 propertyValue.Get( mark );
792 mark = MapValuePercentage( mark );
794 if( fabsf( mark - value ) < MARK_TOLERANCE )
813 bool Slider::HideValueView()
817 mValueDisplay.SetVisible( false );
823 void Slider::SetLowerBound( float bound )
826 DisplayValue( GetValue(), false );
829 float Slider::GetLowerBound() const
834 void Slider::SetUpperBound( float bound )
837 DisplayValue( GetValue(), false );
840 float Slider::GetUpperBound() const
845 void Slider::SetValue( float value )
848 DisplayValue( mValue, true );
851 float Slider::GetValue() const
856 void Slider::SetBackingRegion( const Vector2& region )
858 mBackingRegion = region;
862 mBacking.SetSize( mBackingRegion );
865 ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
867 mDomain = CalcDomain( mBackingRegion );
869 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
872 const Vector2& Slider::GetBackingRegion() const
874 return mBackingRegion;
877 void Slider::SetHandleRegion( const Vector2& region )
879 mHandleRegionSize = region;
881 ResizeHandleRegion( mHandleRegionSize );
883 Vector2 hitRegion = GetHitRegion();
884 hitRegion.x += mHandleRegionSize.x;
885 SetHitRegion( hitRegion );
888 const Vector2& Slider::GetHandleRegion() const
890 return mHandleRegionSize;
893 void Slider::SetDisableColor( const Vector4& color )
895 mDisableColor = color;
900 Vector4 Slider::GetDisableColor() const
902 return mDisableColor;
905 Vector4 Slider::GetPopupTextColor() const
907 return mPopupTextColor;
910 void Slider::SetValuePrecision( int precision )
912 mValuePrecision = precision;
915 int Slider::GetValuePrecision() const
917 return mValuePrecision;
920 void Slider::SetShowPopup( bool showPopup )
922 mShowPopup = showPopup;
935 bool Slider::GetShowPopup() const
940 void Slider::SetShowValue( bool showValue )
942 mShowValue = showValue;
946 CreateHandleValueDisplay();
950 DestroyHandleValueDisplay();
954 bool Slider::GetShowValue() const
959 void Slider::SetEnabled( bool enabled )
973 bool Slider::IsEnabled() const
975 return mState != DISABLED;
978 void Slider::SetMarkTolerance( float tolerance )
980 mMarkTolerance = tolerance;
983 float Slider::GetMarkTolerance() const
985 return mMarkTolerance;
988 // Static class method to support script connecting signals
989 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
991 Dali::BaseHandle handle( object );
993 bool connected = true;
994 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
996 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
998 slider.ValueChangedSignal().Connect( tracker, functor );
1000 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
1002 slider.MarkSignal().Connect( tracker, functor );
1006 // signalName does not match any signal
1013 void Slider::DisplayPopup( float value )
1015 // Value displayDoConnectSignal
1016 if( mValueTextView )
1018 std::stringstream ss;
1019 ss.precision( GetValuePrecision() );
1020 ss << std::fixed << value;
1021 mValueTextView.SetText( ss.str() );
1023 style.SetTextColor( GetPopupTextColor() );
1024 mValueTextView.SetStyleToCurrentText( style, TextStyle::COLOR);
1028 Font font = Font::New();
1029 float popupWidth = font.MeasureText( ss.str() ).x + VALUE_POPUP_MARGIN * 2.0f;
1030 if( popupWidth < VALUE_POPUP_MIN_WIDTH )
1032 popupWidth = VALUE_POPUP_MIN_WIDTH;
1035 mPopup.SetSize( popupWidth, VALUE_POPUP_HEIGHT );
1036 mValueDisplay.SetVisible( true );
1038 mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
1043 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
1045 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1049 Slider& sliderImpl( GetImpl( slider ) );
1051 switch ( propertyIndex )
1053 case Toolkit::Slider::Property::LOWER_BOUND:
1055 sliderImpl.SetLowerBound( value.Get< float >() );
1059 case Toolkit::Slider::Property::UPPER_BOUND:
1061 sliderImpl.SetUpperBound( value.Get< float >() );
1065 case Toolkit::Slider::Property::VALUE:
1067 sliderImpl.SetValue( value.Get< float >() );
1071 case Toolkit::Slider::Property::HIT_REGION:
1073 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1077 case Toolkit::Slider::Property::BACKING_REGION:
1079 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1083 case Toolkit::Slider::Property::HANDLE_REGION:
1085 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1089 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1091 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1095 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1097 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1101 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1103 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1107 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1109 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1113 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1115 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1119 case Toolkit::Slider::Property::DISABLE_COLOR:
1121 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1125 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1127 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1131 case Toolkit::Slider::Property::VALUE_PRECISION:
1133 sliderImpl.SetValuePrecision( value.Get< int >() );
1137 case Toolkit::Slider::Property::SHOW_POPUP:
1139 sliderImpl.SetShowPopup( value.Get< bool >() );
1143 case Toolkit::Slider::Property::SHOW_VALUE:
1145 sliderImpl.SetShowValue( value.Get< bool >() );
1149 case Toolkit::Slider::Property::ENABLED:
1151 sliderImpl.SetEnabled( value.Get< bool >() );
1155 case Toolkit::Slider::Property::MARKS:
1157 sliderImpl.SetMarks( value.Get< Property::Array >() );
1161 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1163 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1167 case Toolkit::Slider::Property::MARK_TOLERANCE:
1169 sliderImpl.SetMarkTolerance( value.Get< float >() );
1176 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1178 Property::Value value;
1180 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1184 Slider& sliderImpl( GetImpl( slider ) );
1186 switch ( propertyIndex )
1188 case Toolkit::Slider::Property::LOWER_BOUND:
1190 value = sliderImpl.GetLowerBound();
1194 case Toolkit::Slider::Property::UPPER_BOUND:
1196 value = sliderImpl.GetUpperBound();
1200 case Toolkit::Slider::Property::VALUE:
1202 value = sliderImpl.GetValue();
1206 case Toolkit::Slider::Property::HIT_REGION:
1208 value = sliderImpl.GetHitRegion();
1212 case Toolkit::Slider::Property::BACKING_REGION:
1214 value = sliderImpl.GetBackingRegion();
1218 case Toolkit::Slider::Property::HANDLE_REGION:
1220 value = sliderImpl.GetHandleRegion();
1224 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1226 value = sliderImpl.GetBackingImageName();
1230 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1232 value = sliderImpl.GetHandleImageName();
1236 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1238 value = sliderImpl.GetProgressImageName();
1242 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1244 value = sliderImpl.GetPopupImageName();
1248 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1250 value = sliderImpl.GetPopupArrowImageName();
1254 case Toolkit::Slider::Property::DISABLE_COLOR:
1256 value = sliderImpl.GetDisableColor();
1260 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1262 value = sliderImpl.GetPopupTextColor();
1266 case Toolkit::Slider::Property::VALUE_PRECISION:
1268 value = sliderImpl.GetValuePrecision();
1272 case Toolkit::Slider::Property::SHOW_POPUP:
1274 value = sliderImpl.GetShowPopup();
1278 case Toolkit::Slider::Property::SHOW_VALUE:
1280 value = sliderImpl.GetShowValue();
1284 case Toolkit::Slider::Property::ENABLED:
1286 value = sliderImpl.IsEnabled();
1290 case Toolkit::Slider::Property::MARKS:
1292 // TODO: Need to be able to return a PropertyArray
1293 // value = sliderImpl.GetMarks();
1297 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1299 value = sliderImpl.GetSnapToMarks();
1303 case Toolkit::Slider::Property::MARK_TOLERANCE:
1305 value = sliderImpl.GetMarkTolerance();
1314 } // namespace Internal
1316 } // namespace Toolkit