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 );
354 void Slider::SetMarks( const MarkList& marks )
357 for( MarkList::const_iterator it = marks.begin(), itEnd = marks.end(); it != itEnd; ++it )
359 const Property::Value& propertyValue = *it;
360 propertyValue.Get( value );
362 mMarks.push_back( value );
366 const Slider::MarkList& Slider::GetMarks() const
371 void Slider::SetSnapToMarks( bool snap )
376 bool Slider::GetSnapToMarks() const
381 Actor Slider::CreateHitRegion()
383 Actor hitRegion = Actor::New();
384 hitRegion.SetParentOrigin( ParentOrigin::CENTER );
385 hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
386 hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
391 ImageActor Slider::CreateBacking()
393 ImageActor backing = ImageActor::New();
394 backing.SetRelayoutEnabled( false );
395 backing.SetParentOrigin( ParentOrigin::CENTER );
396 backing.SetAnchorPoint( AnchorPoint::CENTER );
397 backing.SetZ( BACKING_Z );
402 void Slider::SetBackingImageName( const std::string& imageName )
404 if( mBacking && ( imageName.size() > 0 ) )
406 Image image = ResourceImage::New( imageName );
407 mBacking.SetImage( image );
411 std::string Slider::GetBackingImageName()
415 return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
418 return std::string( "" );
421 ImageActor Slider::CreateProgress()
423 ImageActor progress = ImageActor::New();
424 progress.SetRelayoutEnabled( false );
425 progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
426 progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
427 progress.SetZ( PROGRESS_Z );
432 void Slider::SetProgressImageName( const std::string& imageName )
434 if( mProgress && ( imageName.size() > 0 ) )
436 Image image = ResourceImage::New( imageName );
437 mProgress.SetImage( image );
441 std::string Slider::GetProgressImageName()
445 return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
448 return std::string( "" );
451 void Slider::SetPopupImageName( const std::string& imageName )
453 mPopupImageName = imageName;
456 std::string Slider::GetPopupImageName()
458 return mPopupImageName;
461 void Slider::CreatePopupImage( const std::string& imageName )
463 if( mPopup && ( imageName.size() > 0 ) )
465 Image image = ResourceImage::New( imageName );
466 mPopup.SetImage( image );
470 void Slider::SetPopupArrowImageName( const std::string& imageName )
472 mPopupArrowImageName = imageName;
475 std::string Slider::GetPopupArrowImageName()
477 return mPopupArrowImageName;
480 void Slider::CreatePopupArrowImage( const std::string& imageName )
482 if( mPopupArrow && ( imageName.size() > 0 ) )
484 Image image = ResourceImage::New( imageName );
485 mPopupArrow.SetImage( image );
489 void Slider::ResizeProgressRegion( const Vector2& region )
493 mProgress.SetSize( region );
497 ImageActor Slider::CreateHandle()
499 ImageActor handle = ImageActor::New();
500 handle.SetRelayoutEnabled( false );
501 handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
502 handle.SetAnchorPoint( AnchorPoint::CENTER );
503 handle.SetZ( HANDLE_Z );
508 ImageActor Slider::CreatePopupArrow()
510 ImageActor arrow = ImageActor::New();
511 arrow.SetRelayoutEnabled( false );
512 arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
513 arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
514 arrow.SetZ( HANDLE_Z );
519 //Toolkit::TextView Slider::CreatePopupText()
523 ImageActor Slider::CreatePopup()
525 ImageActor popup = ImageActor::New();
526 popup.SetRelayoutEnabled( false );
527 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
528 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
533 void Slider::SetHandleImageName( const std::string& imageName )
535 if( mHandle && ( imageName.size() > 0 ) )
537 Image image = ResourceImage::New( imageName );
538 mHandle.SetImage( image );
542 std::string Slider::GetHandleImageName()
546 return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
549 return std::string( "" );
552 void Slider::ResizeHandleRegion( const Vector2& region )
556 mHandle.SetSize( region );
560 void Slider::CreateHandleValueDisplay()
564 void Slider::DestroyHandleValueDisplay()
568 void Slider::SetPopupTextColor( const Vector4& color )
570 mPopupTextColor = color;
573 Actor Slider::CreateValueDisplay()
575 Actor popup = Actor::New();
576 popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
577 popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
579 mPopupArrow = CreatePopupArrow();
580 popup.Add( mPopupArrow );
582 mPopup = CreatePopup();
583 mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT );
584 mPopupArrow.Add( mPopup );
589 Toolkit::Slider::ValueChangedSignalType& Slider::ValueChangedSignal()
591 return mValueChangedSignal;
594 Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
596 return mSlidingFinishedSignal;
599 Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
604 void Slider::UpdateSkin()
610 mBacking.SetColor( Color::WHITE );
611 mHandle.SetColor( Color::WHITE );
612 mProgress.SetColor( Color::WHITE );
617 Vector4 disableColor = GetDisableColor();
618 mBacking.SetColor( disableColor );
619 mHandle.SetColor( disableColor );
620 mProgress.SetColor( disableColor );
634 void Slider::CreateChildren()
639 mHitArea = CreateHitRegion();
640 mPanDetector = PanGestureDetector::New();
641 mPanDetector.Attach( mHitArea );
642 mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
643 self.Add( mHitArea );
646 mBacking = CreateBacking();
647 self.Add( mBacking );
650 mProgress = CreateProgress();
651 mBacking.Add( mProgress );
654 mHandle = CreateHandle();
655 mBacking.Add( mHandle );
658 void Slider::SetHitRegion( const Vector2& size )
664 mHitArea.SetSize( mHitRegion );
668 const Vector2& Slider::GetHitRegion() const
673 void Slider::AddPopup()
677 mValueDisplay = CreateValueDisplay();
678 mValueDisplay.SetVisible( false );
679 mHandle.Add( mValueDisplay );
681 CreatePopupImage( GetPopupImageName() );
682 CreatePopupArrowImage( GetPopupArrowImageName() );
684 mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
685 mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
689 void Slider::RemovePopup()
696 mPopupArrow.Unparent();
699 mValueDisplay.Unparent();
700 mValueDisplay.Reset();
702 mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView );
708 float Slider::MarkFilter( float value )
710 const float MARK_TOLERANCE = GetMarkTolerance();
713 for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
715 const Property::Value& propertyValue = *it;
716 propertyValue.Get( mark );
717 mark = MapValuePercentage( mark );
719 // If close to a mark, return the mark
720 if( fabsf( mark - value ) < MARK_TOLERANCE )
729 float Slider::SnapToMark( float value )
731 float closestMark = value;
732 float closestDist = std::numeric_limits<float>::max();
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 float dist = fabsf( mark - value );
742 if( dist < closestDist )
752 bool Slider::MarkReached( float value, int& outIndex )
754 const float MARK_TOLERANCE = GetMarkTolerance();
758 tail = mMarks.size() - 1;
762 while( head <= tail )
764 current = head + ( tail - head ) / 2;
766 const Property::Value& propertyValue = mMarks[ current ];
767 propertyValue.Get( mark );
768 mark = MapValuePercentage( mark );
770 if( fabsf( mark - value ) < MARK_TOLERANCE )
789 bool Slider::HideValueView()
793 mValueDisplay.SetVisible( false );
799 void Slider::SetLowerBound( float bound )
802 DisplayValue( GetValue(), false );
805 float Slider::GetLowerBound() const
810 void Slider::SetUpperBound( float bound )
813 DisplayValue( GetValue(), false );
816 float Slider::GetUpperBound() const
821 void Slider::SetValue( float value )
824 DisplayValue( mValue, true );
827 float Slider::GetValue() const
832 void Slider::SetBackingRegion( const Vector2& region )
834 mBackingRegion = region;
838 mBacking.SetSize( mBackingRegion );
841 ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
843 mDomain = CalcDomain( mBackingRegion );
845 DisplayValue( GetValue(), false ); // Set the progress bar to correct width
848 const Vector2& Slider::GetBackingRegion() const
850 return mBackingRegion;
853 void Slider::SetHandleRegion( const Vector2& region )
855 mHandleRegionSize = region;
857 ResizeHandleRegion( mHandleRegionSize );
859 Vector2 hitRegion = GetHitRegion();
860 hitRegion.x += mHandleRegionSize.x;
861 SetHitRegion( hitRegion );
864 const Vector2& Slider::GetHandleRegion() const
866 return mHandleRegionSize;
869 void Slider::SetDisableColor( const Vector4& color )
871 mDisableColor = color;
876 Vector4 Slider::GetDisableColor() const
878 return mDisableColor;
881 Vector4 Slider::GetPopupTextColor() const
883 return mPopupTextColor;
886 void Slider::SetValuePrecision( int precision )
888 mValuePrecision = precision;
891 int Slider::GetValuePrecision() const
893 return mValuePrecision;
896 void Slider::SetShowPopup( bool showPopup )
898 mShowPopup = showPopup;
911 bool Slider::GetShowPopup() const
916 void Slider::SetShowValue( bool showValue )
918 mShowValue = showValue;
922 CreateHandleValueDisplay();
926 DestroyHandleValueDisplay();
930 bool Slider::GetShowValue() const
935 void Slider::SetEnabled( bool enabled )
949 bool Slider::IsEnabled() const
951 return mState != DISABLED;
954 void Slider::SetMarkTolerance( float tolerance )
956 mMarkTolerance = tolerance;
959 float Slider::GetMarkTolerance() const
961 return mMarkTolerance;
964 // Static class method to support script connecting signals
965 bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
967 Dali::BaseHandle handle( object );
969 bool connected = true;
970 Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
972 if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
974 slider.ValueChangedSignal().Connect( tracker, functor );
976 else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
978 slider.MarkSignal().Connect( tracker, functor );
982 // signalName does not match any signal
989 void Slider::DisplayPopup( float value )
993 void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
995 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
999 Slider& sliderImpl( GetImpl( slider ) );
1001 switch ( propertyIndex )
1003 case Toolkit::Slider::Property::LOWER_BOUND:
1005 sliderImpl.SetLowerBound( value.Get< float >() );
1009 case Toolkit::Slider::Property::UPPER_BOUND:
1011 sliderImpl.SetUpperBound( value.Get< float >() );
1015 case Toolkit::Slider::Property::VALUE:
1017 sliderImpl.SetValue( value.Get< float >() );
1021 case Toolkit::Slider::Property::HIT_REGION:
1023 sliderImpl.SetHitRegion( value.Get< Vector2 >() );
1027 case Toolkit::Slider::Property::BACKING_REGION:
1029 sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
1033 case Toolkit::Slider::Property::HANDLE_REGION:
1035 sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
1039 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1041 sliderImpl.SetBackingImageName( value.Get< std::string >() );
1045 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1047 sliderImpl.SetHandleImageName( value.Get< std::string >() );
1051 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1053 sliderImpl.SetProgressImageName( value.Get< std::string >() );
1057 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1059 sliderImpl.SetPopupImageName( value.Get< std::string >() );
1063 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1065 sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
1069 case Toolkit::Slider::Property::DISABLE_COLOR:
1071 sliderImpl.SetDisableColor( value.Get< Vector4 >() );
1075 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1077 sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
1081 case Toolkit::Slider::Property::VALUE_PRECISION:
1083 sliderImpl.SetValuePrecision( value.Get< int >() );
1087 case Toolkit::Slider::Property::SHOW_POPUP:
1089 sliderImpl.SetShowPopup( value.Get< bool >() );
1093 case Toolkit::Slider::Property::SHOW_VALUE:
1095 sliderImpl.SetShowValue( value.Get< bool >() );
1099 case Toolkit::Slider::Property::ENABLED:
1101 sliderImpl.SetEnabled( value.Get< bool >() );
1105 case Toolkit::Slider::Property::MARKS:
1107 sliderImpl.SetMarks( value.Get< Property::Array >() );
1111 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1113 sliderImpl.SetSnapToMarks( value.Get< bool >() );
1117 case Toolkit::Slider::Property::MARK_TOLERANCE:
1119 sliderImpl.SetMarkTolerance( value.Get< float >() );
1126 Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
1128 Property::Value value;
1130 Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
1134 Slider& sliderImpl( GetImpl( slider ) );
1136 switch ( propertyIndex )
1138 case Toolkit::Slider::Property::LOWER_BOUND:
1140 value = sliderImpl.GetLowerBound();
1144 case Toolkit::Slider::Property::UPPER_BOUND:
1146 value = sliderImpl.GetUpperBound();
1150 case Toolkit::Slider::Property::VALUE:
1152 value = sliderImpl.GetValue();
1156 case Toolkit::Slider::Property::HIT_REGION:
1158 value = sliderImpl.GetHitRegion();
1162 case Toolkit::Slider::Property::BACKING_REGION:
1164 value = sliderImpl.GetBackingRegion();
1168 case Toolkit::Slider::Property::HANDLE_REGION:
1170 value = sliderImpl.GetHandleRegion();
1174 case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
1176 value = sliderImpl.GetBackingImageName();
1180 case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
1182 value = sliderImpl.GetHandleImageName();
1186 case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
1188 value = sliderImpl.GetProgressImageName();
1192 case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
1194 value = sliderImpl.GetPopupImageName();
1198 case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
1200 value = sliderImpl.GetPopupArrowImageName();
1204 case Toolkit::Slider::Property::DISABLE_COLOR:
1206 value = sliderImpl.GetDisableColor();
1210 case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
1212 value = sliderImpl.GetPopupTextColor();
1216 case Toolkit::Slider::Property::VALUE_PRECISION:
1218 value = sliderImpl.GetValuePrecision();
1222 case Toolkit::Slider::Property::SHOW_POPUP:
1224 value = sliderImpl.GetShowPopup();
1228 case Toolkit::Slider::Property::SHOW_VALUE:
1230 value = sliderImpl.GetShowValue();
1234 case Toolkit::Slider::Property::ENABLED:
1236 value = sliderImpl.IsEnabled();
1240 case Toolkit::Slider::Property::MARKS:
1242 // TODO: Need to be able to return a PropertyArray
1243 // value = sliderImpl.GetMarks();
1247 case Toolkit::Slider::Property::SNAP_TO_MARKS:
1249 value = sliderImpl.GetSnapToMarks();
1253 case Toolkit::Slider::Property::MARK_TOLERANCE:
1255 value = sliderImpl.GetMarkTolerance();
1264 } // namespace Internal
1266 } // namespace Toolkit