X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fslider%2Fslider-impl.cpp;h=03883d2f0dbb51f3ce7b360562809faa0f0a663f;hp=1f76447cb24113b43acc8a14622f58ae0579ae0e;hb=699db00c70dc0def70d6cd57ae2ec8c553163021;hpb=306d2f61a1b64179e801fa8a0bb2bd7b4e9dd682 diff --git a/dali-toolkit/internal/controls/slider/slider-impl.cpp b/dali-toolkit/internal/controls/slider/slider-impl.cpp index 1f76447..03883d2 100755 --- a/dali-toolkit/internal/controls/slider/slider-impl.cpp +++ b/dali-toolkit/internal/controls/slider/slider-impl.cpp @@ -19,13 +19,17 @@ #include // EXTERNAL INCLUDES -#include +#include // for strcmp +#include +#include +#include #include +#include +#include -// EXTERNAL INCLUDES +// INTERNAL INCLUDES #include - -#include +#include using namespace Dali; @@ -35,46 +39,40 @@ namespace Dali namespace Toolkit { -// Properties -const Property::Index Slider::LOWER_BOUND_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX; -const Property::Index Slider::UPPER_BOUND_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 1; - -const Property::Index Slider::VALUE_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 2; -const Property::Index Slider::HIT_REGION_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 3; -const Property::Index Slider::BACKING_REGION_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 4; -const Property::Index Slider::HANDLE_REGION_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 5; - -const Property::Index Slider::BACKING_IMAGE_NAME_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 6; -const Property::Index Slider::HANDLE_IMAGE_NAME_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 7; -const Property::Index Slider::PROGRESS_IMAGE_NAME_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 8; -const Property::Index Slider::POPUP_IMAGE_NAME_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 9; -const Property::Index Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 10; - -const Property::Index Slider::DISABLE_COLOR_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 11; -const Property::Index Slider::POPUP_TEXT_COLOR_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 12; +namespace Internal +{ -const Property::Index Slider::VALUE_PRECISION_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 13; +namespace // Unnamed namespace +{ -const Property::Index Slider::SHOW_POPUP_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 14; -const Property::Index Slider::SHOW_VALUE_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 15; +BaseHandle Create() +{ + return Dali::Toolkit::Slider::New(); +} -const Property::Index Slider::ENABLED_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 16; +// Setup properties, signals and actions using the type-registry. +DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create ) -const Property::Index Slider::MARKS_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 17; -const Property::Index Slider::SNAP_TO_MARKS_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 18; -const Property::Index Slider::MARK_TOLERANCE_PROPERTY = Internal::Slider::SLIDER_PROPERTY_START_INDEX + 19; +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "lowerBound", FLOAT, LOWER_BOUND ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "upperBound", FLOAT, UPPER_BOUND ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "value", FLOAT, VALUE ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "trackVisual", MAP, TRACK_VISUAL ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleVisual", MAP, HANDLE_VISUAL ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progressVisual", MAP, PROGRESS_VISUAL ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupVisual", MAP, POPUP_VISUAL ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupArrowVisual", MAP, POPUP_ARROW_VISUAL ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disabledColor", VECTOR4, DISABLED_COLOR ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "valuePrecision", INTEGER, VALUE_PRECISION ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showPopup", BOOLEAN, SHOW_POPUP ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showValue", BOOLEAN, SHOW_VALUE ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "marks", ARRAY, MARKS ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snapToMarks", BOOLEAN, SNAP_TO_MARKS ) +DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "markTolerance", FLOAT, MARK_TOLERANCE ) -namespace Internal -{ +DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED ) +DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "mark", SIGNAL_MARK ) -namespace -{ -const float BACKING_Z = -0.1f; -const float PROGRESS_Z = 0.1f; -const float HANDLE_Z = 1.0f; -const float VALUE_TEXT_INCREMENT = 0.01f; -const float HANDLE_VALUE_DISPLAY_TEXT_Z = HANDLE_Z + VALUE_TEXT_INCREMENT; -const float VALUE_DISPLAY_TEXT_Z = VALUE_TEXT_INCREMENT + VALUE_TEXT_INCREMENT; // Put above HANDLE_VALUE_DISPLAY_TEXT_Z (parented to handle) +DALI_TYPE_REGISTRATION_END() const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width @@ -87,24 +85,23 @@ const float DEFAULT_WIDTH = 0.0f; const float DEFAULT_HEIGHT = 27.0f; const float DEFAULT_HIT_HEIGHT = 72.0f; const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT; +const float POPUP_TEXT_PADDING = 10.0f; -const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.9.png"; -const char* SKINNED_HANDLE_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-handle.png";; -const char* SKINNED_PROGRESS_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-progress.9.png"; -const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.9.png"; -const char* SKINNED_POPUP_ARROW_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup-arrow.png"; +const char* SKINNED_TRACK_VISUAL = DALI_IMAGE_DIR "slider-skin.9.png"; +const char* SKINNED_HANDLE_VISUAL = DALI_IMAGE_DIR "slider-skin-handle.png"; +const char* SKINNED_PROGRESS_VISUAL = DALI_IMAGE_DIR "slider-skin-progress.9.png"; +const char* SKINNED_POPUP_VISUAL = DALI_IMAGE_DIR "slider-popup.9.png"; +const char* SKINNED_POPUP_ARROW_VISUAL = DALI_IMAGE_DIR "slider-popup-arrow.png"; const Vector2 DEFAULT_HIT_REGION( DEFAULT_WIDTH, DEFAULT_HIT_HEIGHT ); -const Vector2 DEFAULT_BACKING_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT ); -const Vector2 DEFAULT_HANDLE_REGION( DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT ); +const Vector2 DEFAULT_TRACK_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT ); +const Vector2 DEFAULT_HANDLE_SIZE( DEFAULT_HANDLE_HEIGHT, DEFAULT_HANDLE_HEIGHT ); -const Vector4 DEFAULT_DISABLE_COLOR( 0.5f, 0.5f, 0.5f, 1.0f ); -const Vector4 DEFAULT_POPUP_TEXT_COLOR( 0.5f, 0.5f, 0.5f, 1.0f ); +const Vector4 DEFAULT_DISABLED_COLOR( 0.5f, 0.5f, 0.5f, 1.0f ); const float VALUE_POPUP_MARGIN = 10.0f; const float VALUE_POPUP_HEIGHT = 81.0f; const float VALUE_POPUP_MIN_WIDTH = 54.0f; -const Vector2 VALUE_POPUP_ARROW_SIZE( 18.0f, 18.0f ); const float DEFAULT_LOWER_BOUND = 0.0f; const float DEFAULT_UPPER_BOUND = 1.0f; @@ -115,45 +112,7 @@ const bool DEFAULT_SHOW_VALUE = true; const bool DEFAULT_ENABLED = true; const bool DEFAULT_SNAP_TO_MARKS = false; -BaseHandle Create() -{ - return Dali::Toolkit::Slider::New(); -} - -TypeRegistration typeRegistration( typeid(Dali::Toolkit::Slider), typeid(Dali::Toolkit::Control), Create ); - -SignalConnectorType signalConnector1( typeRegistration, Toolkit::Slider::SIGNAL_VALUE_CHANGED, &Toolkit::Internal::Slider::DoConnectSignal ); -SignalConnectorType signalConnector2( typeRegistration, Toolkit::Slider::SIGNAL_MARK, &Toolkit::Internal::Slider::DoConnectSignal ); - -PropertyRegistration property1( typeRegistration, "lower-bound", Toolkit::Slider::LOWER_BOUND_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property2( typeRegistration, "upper-bound", Toolkit::Slider::UPPER_BOUND_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property3( typeRegistration, "value", Toolkit::Slider::VALUE_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty ); - -PropertyRegistration property4( typeRegistration, "hit-region", Toolkit::Slider::HIT_REGION_PROPERTY, Property::VECTOR2, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property5( typeRegistration, "backing-region", Toolkit::Slider::BACKING_REGION_PROPERTY, Property::VECTOR2, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property6( typeRegistration, "handle-region", Toolkit::Slider::HANDLE_REGION_PROPERTY, Property::VECTOR2, &Slider::SetProperty, &Slider::GetProperty ); - -PropertyRegistration property7( typeRegistration, "backing-image-name", Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property8( typeRegistration, "handle-image-name", Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property9( typeRegistration, "progress-image-name", Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property10( typeRegistration, "popup-image-name", Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property11( typeRegistration, "popup-arrow-image-name", Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty ); - -PropertyRegistration property12( typeRegistration, "disable-color", Toolkit::Slider::DISABLE_COLOR_PROPERTY, Property::VECTOR4, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property13( typeRegistration, "popup-text-color", Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY, Property::VECTOR4, &Slider::SetProperty, &Slider::GetProperty ); - -PropertyRegistration property14( typeRegistration, "value-precision", Toolkit::Slider::VALUE_PRECISION_PROPERTY, Property::INTEGER, &Slider::SetProperty, &Slider::GetProperty ); - -PropertyRegistration property15( typeRegistration, "show-popup", Toolkit::Slider::SHOW_POPUP_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property16( typeRegistration, "show-value", Toolkit::Slider::SHOW_VALUE_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty ); - -PropertyRegistration property17( typeRegistration, "enabled", Toolkit::Slider::ENABLED_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty ); - -PropertyRegistration property18( typeRegistration, "marks", Toolkit::Slider::MARKS_PROPERTY, Property::ARRAY, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property19( typeRegistration, "snap-to-marks", Toolkit::Slider::SNAP_TO_MARKS_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty ); -PropertyRegistration property20( typeRegistration, "mark-tolerance", Toolkit::Slider::MARK_TOLERANCE_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty ); - -} // namespace +} // Unnamed namespace /////////////////////////////////////////////////////////////////////////////////////////////////// // Slider @@ -175,13 +134,21 @@ Dali::Toolkit::Slider Slider::New() } Slider::Slider() -: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ), +: Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ), mState( NORMAL ), - mDisableColor( 0.0f, 0.0f, 0.0f, 0.0f ), - mPopupTextColor( 0.0f, 0.0f, 0.0f, 0.0f ), + mPopupVisual(""), + mPopupArrowVisual(""), + mTrackVisual(""), + mHandleVisual(""), + mProgressVisual(""), + mPopupMap(), + mTrackMap(), + mHandleMap(), + mPopupArrowMap(), + mDisabledColor( 0.0f, 0.0f, 0.0f, 0.0f ), mHitRegion( 0.0f, 0.0f ), - mBackingRegion( 0.0f, 0.0f ), - mHandleRegionSize( 0.0f, 0.0f ), + mTrackRegion( 0.0f, 0.0f ), + mHandleSize( 0.0f, 0.0f ), mLowerBound( 0.0f ), mUpperBound( 0.0f ), mValue( 0.0f ), @@ -206,22 +173,20 @@ void Slider::OnInitialize() Actor self = Self(); SetHitRegion( DEFAULT_HIT_REGION ); - SetBackingRegion( DEFAULT_BACKING_REGION ); - SetHandleRegion( DEFAULT_HANDLE_REGION ); - - SetBackingImageName( SKINNED_BACKING_IMAGE_NAME ); - SetHandleImageName( SKINNED_HANDLE_IMAGE_NAME ); - SetProgressImageName( SKINNED_PROGRESS_IMAGE_NAME ); - SetPopupImageName( SKINNED_POPUP_IMAGE_NAME ); - SetPopupArrowImageName( SKINNED_POPUP_ARROW_IMAGE_NAME ); + SetTrackRegion( DEFAULT_TRACK_REGION ); + SetHandleSize( DEFAULT_HANDLE_SIZE ); - SetPopupTextColor( DEFAULT_POPUP_TEXT_COLOR ); + SetTrackVisual( SKINNED_TRACK_VISUAL ); + SetHandleVisual( SKINNED_HANDLE_VISUAL ); + SetProgressVisual( SKINNED_PROGRESS_VISUAL ); + SetPopupVisual( SKINNED_POPUP_VISUAL ); + SetPopupArrowVisual( SKINNED_POPUP_ARROW_VISUAL ); SetShowPopup( DEFAULT_SHOW_POPUP ); SetShowValue( DEFAULT_SHOW_VALUE ); SetEnabled( DEFAULT_ENABLED ); - SetDisableColor( DEFAULT_DISABLE_COLOR ); + SetDisabledColor( DEFAULT_DISABLED_COLOR ); SetSnapToMarks( DEFAULT_SNAP_TO_MARKS ); SetMarkTolerance( MARK_SNAP_TOLERANCE ); @@ -235,31 +200,39 @@ void Slider::OnInitialize() // Size the Slider actor to a default self.SetSize( DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y ); + + // Connect to the touch signal + self.TouchSignal().Connect( this, &Slider::OnTouch ); } -void Slider::OnControlSizeSet( const Vector3& size ) +void Slider::OnSizeSet( const Vector3& size ) +{ +} + +void Slider::OnRelayout( const Vector2& size, RelayoutContainer& container ) { - // Factor in handle overshoot into size of backing SetHitRegion( Vector2( size.x, GetHitRegion().y ) ); - SetBackingRegion( Vector2( size.x - GetHandleRegion().x, GetBackingRegion().y ) ); + // Factor in handle overshoot into size of backing + SetTrackRegion( Vector2( size.x - GetHandleSize().x, GetTrackRegion().y ) ); + Control::OnRelayout( size, container ); } -bool Slider::OnTouchEvent(Actor actor, const TouchEvent& event) +bool Slider::OnTouch(Actor actor, const TouchData& touch) { if( mState != DISABLED ) { - TouchPoint::State touchState = event.GetPoint(0).state; + const PointState::Type touchState = touch.GetState(0); - if( touchState == TouchPoint::Down ) + if( touchState == PointState::DOWN ) { mState = PRESSED; - float percentage = MapPercentage( event.GetPoint(0).local ); + float percentage = MapPercentage( touch.GetLocalPosition( 0 ) ); float value = MapBounds( ( GetSnapToMarks() ) ? SnapToMark( percentage ) : MarkFilter( percentage ), GetLowerBound(), GetUpperBound() ); SetValue( value ); DisplayPopup( value ); } - else if( touchState == TouchPoint::Up) + else if( touchState == PointState::UP ) { if( mState == PRESSED ) { @@ -344,54 +317,52 @@ Slider::Domain Slider::CalcDomain( const Vector2& currentSize ) void Slider::DisplayValue( float value, bool raiseSignals ) { - float clampledValue = Clamp( value, GetLowerBound(), GetUpperBound() ); + float clampedValue = Clamp( value, GetLowerBound(), GetUpperBound() ); - float percent = MapValuePercentage( clampledValue ); + float percent = MapValuePercentage( clampedValue ); float x = mDomain.from.x + percent * ( mDomain.to.x - mDomain.from.x ); - mHandle.SetPosition( x, 0.0f, HANDLE_Z ); + mHandle.SetX( x ); // Progress bar if( mProgress ) { - if( clampledValue > 0.0f ) - { - mProgress.SetVisible( true ); // Deliberately set this in case multiple SetValues are fired at once - mProgress.SetSize( x, GetBackingRegion().y ); - } - else - { - mProgress.SetVisible( false ); - } + mProgress.SetSize( x, GetTrackRegion().y ); } // Signals if( raiseSignals ) { Toolkit::Slider self = Toolkit::Slider::DownCast( Self() ); - mValueChangedSignal.Emit( self, clampledValue ); + mValueChangedSignal.Emit( self, clampedValue ); int markIndex; if( MarkReached( percent, markIndex ) ) { - mMarkSignal.Emit( self, markIndex ); + mMarkReachedSignal.Emit( self, markIndex ); } } -} -void Slider::SetMarks( const MarkList& marks ) -{ - float value; - for( MarkList::const_iterator it = marks.begin(), itEnd = marks.end(); it != itEnd; ++it ) + if( mHandleValueTextLabel ) { - const Property::Value& propertyValue = *it; - propertyValue.Get( value ); + std::stringstream ss; + ss.precision( GetValuePrecision() ); + ss << std::fixed << clampedValue; - mMarks.push_back( value ); + std::string label = mHandleValueTextLabel.GetProperty( Toolkit::TextLabel::Property::TEXT ); + if( label.compare(ss.str()) ) + { + mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() ); + } } } +void Slider::SetMarks( const MarkList& marks ) +{ + mMarks = marks; +} + const Slider::MarkList& Slider::GetMarks() const { return mMarks; @@ -412,103 +383,185 @@ Actor Slider::CreateHitRegion() Actor hitRegion = Actor::New(); hitRegion.SetParentOrigin( ParentOrigin::CENTER ); hitRegion.SetAnchorPoint( AnchorPoint::CENTER ); - hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent ); + hitRegion.TouchSignal().Connect( this, &Slider::OnTouch ); return hitRegion; } -ImageActor Slider::CreateBacking() +Toolkit::ImageView Slider::CreateTrack() { - ImageActor backing = ImageActor::New(); - backing.SetParentOrigin( ParentOrigin::CENTER ); - backing.SetAnchorPoint( AnchorPoint::CENTER ); - backing.SetZ( BACKING_Z ); - - return backing; + Toolkit::ImageView track = Toolkit::ImageView::New(); + track.SetName("SliderTrack"); + track.SetParentOrigin( ParentOrigin::CENTER ); + track.SetAnchorPoint( AnchorPoint::CENTER ); + return track; } -void Slider::SetBackingImageName( const std::string& imageName ) +void Slider::SetTrackVisual( const std::string& filename ) { - if( mBacking && imageName != String::EMPTY ) + if( mHandle && ( filename.size() > 0 ) ) { - Image image = Image::New( imageName ); - mBacking.SetImage( image ); + mTrack.SetImage( filename ); + mTrackVisual = filename; } } -std::string Slider::GetBackingImageName() +void Slider::SetTrackVisual( Property::Map map ) { - if( mBacking ) + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) { - return mBacking.GetImage().GetFilename(); + mTrackVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mTrack && ( filename.size() > 0 ) ) + { + mTrack.SetImage( filename ); + mTrackMap = map; + } + } + } + + Property::Value* sizeValue = map.Find( "size" ); + if( sizeValue ) + { + Vector2 size; + if( sizeValue->Get( size ) ) + { + mTrackRegion = size; + if( mTrack ) + { + mTrack.SetSize( mTrackRegion ); + } + + ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) ); + + mDomain = CalcDomain( mTrackRegion ); + + // Set the progress bar to correct width + DisplayValue( GetValue(), false ); + } } +} - return std::string( "" ); +std::string Slider::GetTrackVisual() +{ + return mTrackVisual; } -ImageActor Slider::CreateProgress() +Toolkit::ImageView Slider::CreateProgress() { - ImageActor progress = ImageActor::New(); + Toolkit::ImageView progress = Toolkit::ImageView::New(); + progress.SetName("SliderProgress"); progress.SetParentOrigin( ParentOrigin::CENTER_LEFT ); progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT ); - progress.SetZ( PROGRESS_Z ); return progress; } -void Slider::SetProgressImageName( const std::string& imageName ) +void Slider::SetProgressVisual( const std::string& filename ) { - if( mProgress && imageName != String::EMPTY ) + if( mProgress && ( filename.size() > 0 ) ) { - Image image = Image::New( imageName ); - mProgress.SetImage( image ); + mProgress.SetImage( filename ); + mProgressVisual = filename; } } -std::string Slider::GetProgressImageName() +void Slider::SetProgressVisual( Property::Map map ) { - if( mProgress ) + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) { - return mProgress.GetImage().GetFilename(); + mProgressVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mProgress && ( filename.size() > 0 ) ) + { + mProgress.SetImage( filename ); + mProgressMap = map; + } + } } +} - return std::string( "" ); +std::string Slider::GetProgressVisual() +{ + return mProgressVisual; } -void Slider::SetPopupImageName( const std::string& imageName ) +void Slider::SetPopupVisual( const std::string& filename ) { - mPopupImageName = imageName; + mPopupVisual = filename; } -std::string Slider::GetPopupImageName() +void Slider::SetPopupVisual( Property::Map map ) { - return mPopupImageName; + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) + { + mPopupVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mPopup && ( filename.size() > 0 ) ) + { + mPopup.SetImage( filename ); + mPopupMap = map; + } + } + } } -void Slider::CreatePopupImage( const std::string& imageName ) +std::string Slider::GetPopupVisual() { - if( mPopup && imageName != String::EMPTY ) + return mPopupVisual; +} + +void Slider::CreatePopupImage( const std::string& filename ) +{ + if( mPopup && ( filename.size() > 0 ) ) { - Image image = Image::New( imageName ); + Image image = ResourceImage::New( filename ); mPopup.SetImage( image ); } } -void Slider::SetPopupArrowImageName( const std::string& imageName ) +void Slider::SetPopupArrowVisual( const std::string& filename ) { - mPopupArrowImageName = imageName; + mPopupArrowVisual = filename; } -std::string Slider::GetPopupArrowImageName() +void Slider::SetPopupArrowVisual( Property::Map map ) { - return mPopupArrowImageName; + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) + { + mPopupArrowVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mPopupArrow && ( filename.size() > 0 ) ) + { + mPopupArrow.SetImage( filename ); + mPopupArrowMap = map; + } + } + } +} + +std::string Slider::GetPopupArrowVisual() +{ + return mPopupArrowVisual; } -void Slider::CreatePopupArrowImage( const std::string& imageName ) +void Slider::CreatePopupArrowImage( const std::string& filename ) { - if( mPopupArrow && imageName != String::EMPTY ) + if( mPopupArrow && ( filename.size() > 0 ) ) { - Image image = Image::New( imageName ); + Image image = ResourceImage::New( filename ); mPopupArrow.SetImage( image ); } } @@ -521,77 +574,128 @@ void Slider::ResizeProgressRegion( const Vector2& region ) } } -ImageActor Slider::CreateHandle() +Toolkit::ImageView Slider::CreateHandle() { - ImageActor handle = ImageActor::New(); + Toolkit::ImageView handle = Toolkit::ImageView::New(); + handle.SetName("SliderHandle"); handle.SetParentOrigin( ParentOrigin::CENTER_LEFT ); handle.SetAnchorPoint( AnchorPoint::CENTER ); - handle.SetZ( HANDLE_Z ); return handle; } -ImageActor Slider::CreatePopupArrow() +Toolkit::ImageView Slider::CreatePopupArrow() { - ImageActor arrow = ImageActor::New(); + Toolkit::ImageView arrow = Toolkit::ImageView::New(); + arrow.SetStyleName("SliderPopupArrow"); + arrow.SetName("SliderPopupArrow"); arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER ); arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER ); - arrow.SetZ( HANDLE_Z ); return arrow; } -//Toolkit::TextView Slider::CreatePopupText() -//{ -//} +Toolkit::TextLabel Slider::CreatePopupText() +{ + Toolkit::TextLabel textLabel = Toolkit::TextLabel::New(); + textLabel.SetName( "SliderPopupTextLabel" ); + textLabel.SetStyleName( "SliderPopupTextLabel" ); + textLabel.SetParentOrigin( ParentOrigin::CENTER ); + textLabel.SetAnchorPoint( AnchorPoint::CENTER ); + textLabel.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS ); + textLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" ); + textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" ); + textLabel.SetPadding( Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) ); + return textLabel; +} -ImageActor Slider::CreatePopup() +Toolkit::ImageView Slider::CreatePopup() { - ImageActor popup = ImageActor::New(); + Toolkit::ImageView popup = Toolkit::ImageView::New(); + popup.SetName( "SliderPopup" ); popup.SetParentOrigin( ParentOrigin::TOP_CENTER ); popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER ); + popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH ); + + mValueTextLabel = CreatePopupText(); + popup.Add( mValueTextLabel ); return popup; } -void Slider::SetHandleImageName( const std::string& imageName ) +void Slider::SetHandleVisual( const std::string& filename ) { - if( mHandle && imageName != String::EMPTY ) + if( mHandle && ( filename.size() > 0 ) ) { - Image image = Image::New( imageName ); - mHandle.SetImage( image ); + mHandle.SetImage( filename ); + mHandleVisual = filename; } } -std::string Slider::GetHandleImageName() +void Slider::SetHandleVisual( Property::Map map ) { - if( mHandle ) + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) { - return mHandle.GetImage().GetFilename(); + mHandleVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mHandle && ( filename.size() > 0 ) ) + { + mHandle.SetImage( filename ); + mHandleMap = map; + } + } } - return std::string( "" ); + Property::Value* sizeValue = map.Find( "size" ); + if( sizeValue ) + { + Vector2 size; + if( sizeValue->Get( size ) ) + { + mHandleSize = size; + ResizeHandleSize( mHandleSize ); + + Vector2 hitRegion = GetHitRegion(); + hitRegion.x += mHandleSize.x; + SetHitRegion( hitRegion ); + } + } } -void Slider::ResizeHandleRegion( const Vector2& region ) +std::string Slider::GetHandleVisual() +{ + return mHandleVisual; +} + +void Slider::ResizeHandleSize( const Vector2& size ) { if( mHandle ) { - mHandle.SetSize( region ); + mHandle.SetSize( size ); } } void Slider::CreateHandleValueDisplay() { + if( mHandle && !mHandleValueTextLabel ) + { + mHandleValueTextLabel = Toolkit::TextLabel::New(); + mHandleValueTextLabel.SetName("SliderHandleTextLabel"); + mHandleValueTextLabel.SetStyleName("SliderHandleTextLabel"); + mHandleValueTextLabel.SetParentOrigin( ParentOrigin::CENTER ); + mHandleValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER ); + mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" ); + mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" ); + mHandle.Add( mHandleValueTextLabel ); + } } void Slider::DestroyHandleValueDisplay() { -} - -void Slider::SetPopupTextColor( const Vector4& color ) -{ - mPopupTextColor = color; + UnparentAndReset(mHandleValueTextLabel); } Actor Slider::CreateValueDisplay() @@ -620,9 +724,9 @@ Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal() return mSlidingFinishedSignal; } -Toolkit::Slider::MarkSignalType& Slider::MarkSignal() +Toolkit::Slider::MarkReachedSignalType& Slider::MarkReachedSignal() { - return mMarkSignal; + return mMarkReachedSignal; } void Slider::UpdateSkin() @@ -631,17 +735,17 @@ void Slider::UpdateSkin() { case NORMAL: { - mBacking.SetColor( Color::WHITE ); + mTrack.SetColor( Color::WHITE ); mHandle.SetColor( Color::WHITE ); mProgress.SetColor( Color::WHITE ); break; } case DISABLED: { - Vector4 disableColor = GetDisableColor(); - mBacking.SetColor( disableColor ); - mHandle.SetColor( disableColor ); - mProgress.SetColor( disableColor ); + Vector4 disabledColor = GetDisabledColor(); + mTrack.SetColor( disabledColor ); + mHandle.SetColor( disabledColor ); + mProgress.SetColor( disabledColor ); break; } case PRESSED: @@ -666,17 +770,17 @@ void Slider::CreateChildren() mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan ); self.Add( mHitArea ); - // Background - mBacking = CreateBacking(); - self.Add( mBacking ); + // Track + mTrack = CreateTrack(); + self.Add( mTrack ); // Progress bar mProgress = CreateProgress(); - mBacking.Add( mProgress ); + mTrack.Add( mProgress ); // Handle mHandle = CreateHandle(); - mBacking.Add( mHandle ); + mProgress.Add( mHandle ); } void Slider::SetHitRegion( const Vector2& size ) @@ -702,8 +806,8 @@ void Slider::AddPopup() mValueDisplay.SetVisible( false ); mHandle.Add( mValueDisplay ); - CreatePopupImage( GetPopupImageName() ); - CreatePopupArrowImage( GetPopupArrowImageName() ); + CreatePopupImage( GetPopupVisual() ); + CreatePopupArrowImage( GetPopupArrowVisual() ); mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION ); mValueTimer.TickSignal().Connect( this, &Slider::HideValueView ); @@ -734,9 +838,9 @@ float Slider::MarkFilter( float value ) const float MARK_TOLERANCE = GetMarkTolerance(); float mark; - for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it ) + for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i) { - const Property::Value& propertyValue = *it; + const Property::Value& propertyValue = mMarks[i]; propertyValue.Get( mark ); mark = MapValuePercentage( mark ); @@ -756,9 +860,9 @@ float Slider::SnapToMark( float value ) float closestDist = std::numeric_limits::max(); float mark; - for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it ) + for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i) { - const Property::Value& propertyValue = *it; + const Property::Value& propertyValue = mMarks[i]; propertyValue.Get( mark ); mark = MapValuePercentage( mark ); @@ -779,7 +883,7 @@ bool Slider::MarkReached( float value, int& outIndex ) // Binary search int head = 0, - tail = mMarks.size() - 1; + tail = mMarks.Size() - 1; int current; float mark; @@ -796,16 +900,14 @@ bool Slider::MarkReached( float value, int& outIndex ) outIndex = current; return true; } + + if( value < mark ) + { + tail = current - 1; + } else { - if( value < mark ) - { - tail = current - 1; - } - else - { - head = current + 1; - } + head = current + 1; } } @@ -855,58 +957,53 @@ float Slider::GetValue() const return mValue; } -void Slider::SetBackingRegion( const Vector2& region ) +void Slider::SetTrackRegion( const Vector2& region ) { - mBackingRegion = region; + mTrackRegion = region; - if( mBacking ) + if( mTrack ) { - mBacking.SetSize( mBackingRegion ); + mTrack.SetSize( mTrackRegion ); } - ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) ); + ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) ); - mDomain = CalcDomain( mBackingRegion ); + mDomain = CalcDomain( mTrackRegion ); DisplayValue( GetValue(), false ); // Set the progress bar to correct width } -const Vector2& Slider::GetBackingRegion() const +const Vector2& Slider::GetTrackRegion() const { - return mBackingRegion; + return mTrackRegion; } -void Slider::SetHandleRegion( const Vector2& region ) +void Slider::SetHandleSize( const Vector2& size ) { - mHandleRegionSize = region; + mHandleSize = size; - ResizeHandleRegion( mHandleRegionSize ); + ResizeHandleSize( mHandleSize ); Vector2 hitRegion = GetHitRegion(); - hitRegion.x += mHandleRegionSize.x; + hitRegion.x += mHandleSize.x; SetHitRegion( hitRegion ); } -const Vector2& Slider::GetHandleRegion() const +const Vector2& Slider::GetHandleSize() const { - return mHandleRegionSize; + return mHandleSize; } -void Slider::SetDisableColor( const Vector4& color ) +void Slider::SetDisabledColor( const Vector4& color ) { - mDisableColor = color; + mDisabledColor = color; UpdateSkin(); } -Vector4 Slider::GetDisableColor() const -{ - return mDisableColor; -} - -Vector4 Slider::GetPopupTextColor() const +Vector4 Slider::GetDisabledColor() const { - return mPopupTextColor; + return mDisabledColor; } void Slider::SetValuePrecision( int precision ) @@ -987,8 +1084,7 @@ float Slider::GetMarkTolerance() const return mMarkTolerance; } -// static class method to support script connecting signals - +// Static class method to support script connecting signals bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ) { Dali::BaseHandle handle( object ); @@ -996,13 +1092,13 @@ bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tr bool connected = true; Toolkit::Slider slider = Toolkit::Slider::DownCast( handle ); - if( signalName == Dali::Toolkit::Slider::SIGNAL_VALUE_CHANGED ) + if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) ) { slider.ValueChangedSignal().Connect( tracker, functor ); } - else if( signalName == Dali::Toolkit::Slider::SIGNAL_MARK ) + else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) ) { - slider.MarkSignal().Connect( tracker, functor ); + slider.MarkReachedSignal().Connect( tracker, functor ); } else { @@ -1015,6 +1111,21 @@ bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tr void Slider::DisplayPopup( float value ) { + // Value displayDoConnectSignal + if( mValueTextLabel ) + { + std::stringstream ss; + ss.precision( GetValuePrecision() ); + ss << std::fixed << value; + mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() ); + + if( mValueDisplay ) + { + mValueDisplay.SetVisible( true ); + + mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION ); + } + } } void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value ) @@ -1027,121 +1138,119 @@ void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, con switch ( propertyIndex ) { - case Toolkit::Slider::LOWER_BOUND_PROPERTY: + case Toolkit::Slider::Property::LOWER_BOUND: { sliderImpl.SetLowerBound( value.Get< float >() ); break; } - case Toolkit::Slider::UPPER_BOUND_PROPERTY: + case Toolkit::Slider::Property::UPPER_BOUND: { sliderImpl.SetUpperBound( value.Get< float >() ); break; } - case Toolkit::Slider::VALUE_PROPERTY: + case Toolkit::Slider::Property::VALUE: { sliderImpl.SetValue( value.Get< float >() ); break; } - case Toolkit::Slider::HIT_REGION_PROPERTY: - { - sliderImpl.SetHitRegion( value.Get< Vector2 >() ); - break; - } - - case Toolkit::Slider::BACKING_REGION_PROPERTY: - { - sliderImpl.SetBackingRegion( value.Get< Vector2 >() ); - break; - } - - case Toolkit::Slider::HANDLE_REGION_PROPERTY: + case Toolkit::Slider::Property::TRACK_VISUAL: { - sliderImpl.SetHandleRegion( value.Get< Vector2 >() ); + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetTrackVisual( map ); + } break; } - case Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY: + case Toolkit::Slider::Property::HANDLE_VISUAL: { - sliderImpl.SetBackingImageName( value.Get< std::string >() ); + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetHandleVisual( map ); + } break; } - case Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY: + case Toolkit::Slider::Property::PROGRESS_VISUAL: { - sliderImpl.SetHandleImageName( value.Get< std::string >() ); + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetProgressVisual( map ); + } break; } - case Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY: + case Toolkit::Slider::Property::POPUP_VISUAL: { - sliderImpl.SetProgressImageName( value.Get< std::string >() ); - break; - } + std::string imageUrl; + if( value.Get( imageUrl ) ) + { + sliderImpl.SetPopupVisual( imageUrl ); + } - case Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY: - { - sliderImpl.SetPopupImageName( value.Get< std::string >() ); - break; - } + // If it is not a string, then get a Property::Map from the property if possible. + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetPopupVisual( map ); + } - case Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY: - { - sliderImpl.SetPopupArrowImageName( value.Get< std::string >() ); break; } - case Toolkit::Slider::DISABLE_COLOR_PROPERTY: + case Toolkit::Slider::Property::POPUP_ARROW_VISUAL: { - sliderImpl.SetDisableColor( value.Get< Vector4 >() ); + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetPopupArrowVisual( map ); + } break; } - case Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY: + case Toolkit::Slider::Property::DISABLED_COLOR: { - sliderImpl.SetPopupTextColor( value.Get< Vector4 >() ); + sliderImpl.SetDisabledColor( value.Get< Vector4 >() ); break; } - case Toolkit::Slider::VALUE_PRECISION_PROPERTY: + case Toolkit::Slider::Property::VALUE_PRECISION: { sliderImpl.SetValuePrecision( value.Get< int >() ); break; } - case Toolkit::Slider::SHOW_POPUP_PROPERTY: + case Toolkit::Slider::Property::SHOW_POPUP: { sliderImpl.SetShowPopup( value.Get< bool >() ); break; } - case Toolkit::Slider::SHOW_VALUE_PROPERTY: + case Toolkit::Slider::Property::SHOW_VALUE: { sliderImpl.SetShowValue( value.Get< bool >() ); break; } - case Toolkit::Slider::ENABLED_PROPERTY: - { - sliderImpl.SetEnabled( value.Get< bool >() ); - break; - } - - case Toolkit::Slider::MARKS_PROPERTY: + case Toolkit::Slider::Property::MARKS: { sliderImpl.SetMarks( value.Get< Property::Array >() ); break; } - case Toolkit::Slider::SNAP_TO_MARKS_PROPERTY: + case Toolkit::Slider::Property::SNAP_TO_MARKS: { sliderImpl.SetSnapToMarks( value.Get< bool >() ); break; } - case Toolkit::Slider::MARK_TOLERANCE_PROPERTY: + case Toolkit::Slider::Property::MARK_TOLERANCE: { sliderImpl.SetMarkTolerance( value.Get< float >() ); break; @@ -1162,122 +1271,127 @@ Property::Value Slider::GetProperty( BaseObject* object, Property::Index propert switch ( propertyIndex ) { - case Toolkit::Slider::LOWER_BOUND_PROPERTY: + case Toolkit::Slider::Property::LOWER_BOUND: { value = sliderImpl.GetLowerBound(); break; } - case Toolkit::Slider::UPPER_BOUND_PROPERTY: + case Toolkit::Slider::Property::UPPER_BOUND: { value = sliderImpl.GetUpperBound(); break; } - case Toolkit::Slider::VALUE_PROPERTY: + case Toolkit::Slider::Property::VALUE: { value = sliderImpl.GetValue(); break; } - case Toolkit::Slider::HIT_REGION_PROPERTY: - { - value = sliderImpl.GetHitRegion(); - break; - } - - case Toolkit::Slider::BACKING_REGION_PROPERTY: - { - value = sliderImpl.GetBackingRegion(); - break; - } - - case Toolkit::Slider::HANDLE_REGION_PROPERTY: - { - value = sliderImpl.GetHandleRegion(); - break; - } - - case Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY: - { - value = sliderImpl.GetBackingImageName(); - break; - } - - case Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY: + case Toolkit::Slider::Property::TRACK_VISUAL: { - value = sliderImpl.GetHandleImageName(); + if( !sliderImpl.mTrackVisual.empty() ) + { + value = sliderImpl.GetTrackVisual(); + } + else if( !sliderImpl.mTrackMap.Empty() ) + { + value = sliderImpl.mTrackMap; + } break; } - case Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY: + case Toolkit::Slider::Property::HANDLE_VISUAL: { - value = sliderImpl.GetProgressImageName(); + if( !sliderImpl.mHandleVisual.empty() ) + { + value = sliderImpl.GetHandleVisual(); + } + else if( !sliderImpl.mHandleMap.Empty() ) + { + value = sliderImpl.mHandleMap; + } break; } - case Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY: + case Toolkit::Slider::Property::PROGRESS_VISUAL: { - value = sliderImpl.GetPopupImageName(); + if( !sliderImpl.mProgressVisual.empty() ) + { + value = sliderImpl.GetProgressVisual(); + } + else if( !sliderImpl.mProgressMap.Empty() ) + { + value = sliderImpl.mProgressMap; + } break; } - case Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY: + case Toolkit::Slider::Property::POPUP_VISUAL: { - value = sliderImpl.GetPopupArrowImageName(); + if( !sliderImpl.mPopupVisual.empty() ) + { + value = sliderImpl.GetPopupVisual(); + } + else if( !sliderImpl.mPopupMap.Empty() ) + { + value = sliderImpl.mPopupMap; + } break; } - case Toolkit::Slider::DISABLE_COLOR_PROPERTY: + case Toolkit::Slider::Property::POPUP_ARROW_VISUAL: { - value = sliderImpl.GetDisableColor(); + if( !sliderImpl.mPopupArrowVisual.empty() ) + { + value = sliderImpl.GetPopupArrowVisual(); + } + else if( !sliderImpl.mPopupArrowMap.Empty() ) + { + value = sliderImpl.mPopupArrowMap; + } break; } - case Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY: + case Toolkit::Slider::Property::DISABLED_COLOR: { - value = sliderImpl.GetPopupTextColor(); + value = sliderImpl.GetDisabledColor(); break; } - case Toolkit::Slider::VALUE_PRECISION_PROPERTY: + case Toolkit::Slider::Property::VALUE_PRECISION: { value = sliderImpl.GetValuePrecision(); break; } - case Toolkit::Slider::SHOW_POPUP_PROPERTY: + case Toolkit::Slider::Property::SHOW_POPUP: { value = sliderImpl.GetShowPopup(); break; } - case Toolkit::Slider::SHOW_VALUE_PROPERTY: + case Toolkit::Slider::Property::SHOW_VALUE: { value = sliderImpl.GetShowValue(); break; } - case Toolkit::Slider::ENABLED_PROPERTY: - { - value = sliderImpl.IsEnabled(); - break; - } - - case Toolkit::Slider::MARKS_PROPERTY: + case Toolkit::Slider::Property::MARKS: { // TODO: Need to be able to return a PropertyArray // value = sliderImpl.GetMarks(); break; } - case Toolkit::Slider::SNAP_TO_MARKS_PROPERTY: + case Toolkit::Slider::Property::SNAP_TO_MARKS: { value = sliderImpl.GetSnapToMarks(); break; } - case Toolkit::Slider::MARK_TOLERANCE_PROPERTY: + case Toolkit::Slider::Property::MARK_TOLERANCE: { value = sliderImpl.GetMarkTolerance(); break;