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=8cac5edfbc7ed07171ae60e6c4d503b58459698f;hp=5cc9b2375e04733bbc4b7da8afcad81531399dc7;hb=646440beeb663fc5efcccadeba73dd46016ed1b3;hpb=9c779d53223a5eae3be6f8af12954cea364a606b diff --git a/dali-toolkit/internal/controls/slider/slider-impl.cpp b/dali-toolkit/internal/controls/slider/slider-impl.cpp old mode 100755 new mode 100644 index 5cc9b23..8cac5ed --- a/dali-toolkit/internal/controls/slider/slider-impl.cpp +++ b/dali-toolkit/internal/controls/slider/slider-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,105 +19,98 @@ #include // EXTERNAL INCLUDES -#include // for strcmp -#include -#include #include -#include #include -#include +#include +#include // for strcmp +#include +#include // INTERNAL INCLUDES +#include +#include #include #include +#include using namespace Dali; namespace Dali { - namespace Toolkit { - namespace Internal { - namespace // Unnamed namespace { - BaseHandle Create() { return Dali::Toolkit::Slider::New(); } +// clang-format off // Setup properties, signals and actions using the type-registry. -DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create ) - -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, "hitRegion", VECTOR2, HIT_REGION ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backingRegion", VECTOR2, BACKING_REGION ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleRegion", VECTOR2, HANDLE_REGION ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backingImageName", STRING, BACKING_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleImageName", STRING, HANDLE_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progressImageName", STRING, PROGRESS_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupImageName", STRING, POPUP_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupArrowImageName", STRING, POPUP_ARROW_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disableColor", VECTOR4, DISABLE_COLOR ) -DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupTextColor", VECTOR4, POPUP_TEXT_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, "enabled", BOOLEAN, ENABLED ) -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 ) - -DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED ) -DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "mark", SIGNAL_MARK ) +DALI_TYPE_REGISTRATION_BEGIN(Toolkit::Slider, Toolkit::Control, Create ) + +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 ) + +DALI_SIGNAL_REGISTRATION(Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED) +DALI_SIGNAL_REGISTRATION(Toolkit, Slider, "mark", SIGNAL_MARK ) DALI_TYPE_REGISTRATION_END() +// clang-format on const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width -const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec -const int VALUE_VIEW_SHOW_DURATION_LONG = 2000; // millisec +const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec +const int VALUE_VIEW_SHOW_DURATION_LONG = 2000; // millisec const float VALUE_VERTICAL_OFFSET = 48.0f; -const float DEFAULT_WIDTH = 0.0f; -const float DEFAULT_HEIGHT = 27.0f; -const float DEFAULT_HIT_HEIGHT = 72.0f; +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 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_FILE_NAME = "slider-skin.9.png"; +const char* SKINNED_HANDLE_VISUAL_FILE_NAME = "slider-skin-handle.png"; +const char* SKINNED_PROGRESS_VISUAL_FILE_NAME = "slider-skin-progress.9.png"; +const char* SKINNED_POPUP_VISUAL_FILE_NAME = "slider-popup.9.png"; +const char* SKINNED_POPUP_ARROW_VISUAL_FILE_NAME = "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_HIT_REGION(DEFAULT_WIDTH, DEFAULT_HIT_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_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; -const float DEFAULT_VALUE = 0.0f; -const int DEFAULT_VALUE_PRECISION = 0; -const bool DEFAULT_SHOW_POPUP = false; -const bool DEFAULT_SHOW_VALUE = true; -const bool DEFAULT_ENABLED = true; -const bool DEFAULT_SNAP_TO_MARKS = false; +const float DEFAULT_LOWER_BOUND = 0.0f; +const float DEFAULT_UPPER_BOUND = 1.0f; +const float DEFAULT_VALUE = 0.0f; +const int DEFAULT_VALUE_PRECISION = 0; +const bool DEFAULT_SHOW_POPUP = false; +const bool DEFAULT_SHOW_VALUE = true; +const bool DEFAULT_ENABLED = true; +const bool DEFAULT_SNAP_TO_MARKS = false; } // Unnamed namespace @@ -128,10 +121,10 @@ const bool DEFAULT_SNAP_TO_MARKS = false; Dali::Toolkit::Slider Slider::New() { // Create the implementation - SliderPtr slider( new Slider() ); + SliderPtr slider(new Slider()); // Pass ownership to CustomActor via derived handle - Dali::Toolkit::Slider handle( *slider ); + Dali::Toolkit::Slider handle(*slider); // Second-phase init of the implementation // This can only be done after the CustomActor connection has been made... @@ -141,26 +134,29 @@ Dali::Toolkit::Slider Slider::New() } Slider::Slider() -: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ), - mState( NORMAL ), - mPopupImageName(""), - mPopupArrowImageName(""), - mBackingImageName(""), - mHandleImageName(""), - mProgressImageName(""), - mDisableColor( 0.0f, 0.0f, 0.0f, 0.0f ), - mPopupTextColor( 0.0f, 0.0f, 0.0f, 0.0f ), - mHitRegion( 0.0f, 0.0f ), - mBackingRegion( 0.0f, 0.0f ), - mHandleRegionSize( 0.0f, 0.0f ), - mLowerBound( 0.0f ), - mUpperBound( 0.0f ), - mValue( 0.0f ), - mMarkTolerance( 0.0f ), - mValuePrecision( 0 ), - mShowPopup( false ), - mShowValue( false ), - mSnapToMarks( false ) +: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)), + mState(NORMAL), + mPopupVisual(""), + mPopupArrowVisual(""), + mTrackVisual(""), + mHandleVisual(""), + mProgressVisual(""), + mPopupMap(), + mTrackMap(), + mHandleMap(), + mPopupArrowMap(), + mDisabledColor(0.0f, 0.0f, 0.0f, 0.0f), + mHitRegion(0.0f, 0.0f), + mTrackRegion(0.0f, 0.0f), + mHandleSize(0.0f, 0.0f), + mLowerBound(0.0f), + mUpperBound(0.0f), + mValue(0.0f), + mMarkTolerance(0.0f), + mValuePrecision(0), + mShowPopup(false), + mShowValue(false), + mSnapToMarks(false) { } @@ -176,101 +172,112 @@ void Slider::OnInitialize() // Properties 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 ); + SetHitRegion(DEFAULT_HIT_REGION); + SetTrackRegion(DEFAULT_TRACK_REGION); + SetHandleSize(DEFAULT_HANDLE_SIZE); - SetPopupTextColor( DEFAULT_POPUP_TEXT_COLOR ); + const std::string imageDirPath = AssetManager::GetDaliImagePath(); + SetTrackVisual(imageDirPath + SKINNED_TRACK_VISUAL_FILE_NAME); + SetHandleVisual(imageDirPath + SKINNED_HANDLE_VISUAL_FILE_NAME); + SetProgressVisual(imageDirPath + SKINNED_PROGRESS_VISUAL_FILE_NAME); + SetPopupVisual(imageDirPath + SKINNED_POPUP_VISUAL_FILE_NAME); + SetPopupArrowVisual(imageDirPath + SKINNED_POPUP_ARROW_VISUAL_FILE_NAME); - SetShowPopup( DEFAULT_SHOW_POPUP ); - SetShowValue( DEFAULT_SHOW_VALUE ); + SetShowPopup(DEFAULT_SHOW_POPUP); + SetShowValue(DEFAULT_SHOW_VALUE); - SetEnabled( DEFAULT_ENABLED ); - SetDisableColor( DEFAULT_DISABLE_COLOR ); + SetEnabled(DEFAULT_ENABLED); + SetDisabledColor(DEFAULT_DISABLED_COLOR); - SetSnapToMarks( DEFAULT_SNAP_TO_MARKS ); - SetMarkTolerance( MARK_SNAP_TOLERANCE ); + SetSnapToMarks(DEFAULT_SNAP_TO_MARKS); + SetMarkTolerance(MARK_SNAP_TOLERANCE); - SetLowerBound( DEFAULT_LOWER_BOUND ); - SetUpperBound( DEFAULT_UPPER_BOUND ); + SetLowerBound(DEFAULT_LOWER_BOUND); + SetUpperBound(DEFAULT_UPPER_BOUND); UpdateSkin(); - SetValuePrecision( DEFAULT_VALUE_PRECISION ); + SetValuePrecision(DEFAULT_VALUE_PRECISION); mValue = DEFAULT_VALUE; - DisplayValue( mValue, false ); // Run this last to display the correct value + DisplayValue(mValue, false); // Run this last to display the correct value // Size the Slider actor to a default - self.SetSize( DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y ); + self.SetProperty(Actor::Property::SIZE, Vector2(DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y)); + + // Set the Slider to be highlightable in Screen Reader mode + self.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true); + + // Connect to the touch signal + self.TouchedSignal().Connect(this, &Slider::OnTouch); + + DevelControl::SetAccessibilityConstructor(self, [](Dali::Actor actor) { + return std::unique_ptr( + new AccessibleImpl(actor, Dali::Accessibility::Role::SLIDER)); + }); } -void Slider::OnSizeSet( const Vector3& size ) +void Slider::OnRelayout(const Vector2& size, RelayoutContainer& container) { + SetHitRegion(Vector2(size.x, GetHitRegion().y)); // Factor in handle overshoot into size of backing - SetHitRegion( Vector2( size.x, GetHitRegion().y ) ); - SetBackingRegion( Vector2( size.x - GetHandleRegion().x, GetBackingRegion().y ) ); + 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 TouchEvent& touch) { - if( mState != DISABLED ) + 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 value = MapBounds( ( GetSnapToMarks() ) ? SnapToMark( percentage ) : MarkFilter( percentage ), GetLowerBound(), GetUpperBound() ); - SetValue( value ); - DisplayPopup( value ); + 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 ) + if(mState == PRESSED) { mState = NORMAL; - mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() ); + mSlidingFinishedSignal.Emit(Toolkit::Slider::DownCast(Self()), GetValue()); } } } - return true; + return false; } -void Slider::OnPan( Actor actor, const PanGesture& gesture ) +void Slider::OnPan(Actor actor, const PanGesture& gesture) { // gesture.position is in local actor coordinates - if( mState != DISABLED ) + if(mState != DISABLED) { - switch( gesture.state ) + switch(gesture.GetState()) { - case Gesture::Continuing: + case GestureState::CONTINUING: { - if( mState == PRESSED ) + if(mState == PRESSED) { - float value = MapBounds( MarkFilter ( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() ); - SetValue( value ); - DisplayPopup( value ); + float value = MapBounds(MarkFilter(MapPercentage(gesture.GetPosition())), GetLowerBound(), GetUpperBound()); + SetValue(value); + DisplayPopup(value); } break; } - case Gesture::Finished: + case GestureState::FINISHED: { - if( mState == PRESSED ) + if(mState == PRESSED) { - if( GetSnapToMarks() ) + if(GetSnapToMarks()) { - float value = MapBounds( SnapToMark( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() ); - SetValue( value ); - DisplayPopup( value ); + float value = MapBounds(SnapToMark(MapPercentage(gesture.GetPosition())), GetLowerBound(), GetUpperBound()); + SetValue(value); + DisplayPopup(value); } - mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() ); + mSlidingFinishedSignal.Emit(Toolkit::Slider::DownCast(Self()), GetValue()); } mState = NORMAL; @@ -284,75 +291,79 @@ void Slider::OnPan( Actor actor, const PanGesture& gesture ) } } -float Slider::HitSpaceToDomain( float x ) +float Slider::HitSpaceToDomain(float x) { float halfRegionWidth = GetHitRegion().x * 0.5f; - float halfDomainWidth = ( mDomain.to.x - mDomain.from.x ) * 0.5f; - float endDiff = halfRegionWidth - halfDomainWidth; + float halfDomainWidth = (mDomain.to.x - mDomain.from.x) * 0.5f; + float endDiff = halfRegionWidth - halfDomainWidth; return x - endDiff; } -float Slider::MapPercentage( const Vector2& point ) +float Slider::MapPercentage(const Vector2& point) { - return Clamp( ( HitSpaceToDomain( point.x ) - mDomain.from.x ) / ( mDomain.to.x - mDomain.from.x ), 0.0f, 1.0f ); + return Clamp((HitSpaceToDomain(point.x) - mDomain.from.x) / (mDomain.to.x - mDomain.from.x), 0.0f, 1.0f); } -float Slider::MapValuePercentage( float value ) +float Slider::MapValuePercentage(float value) { - return ( value - GetLowerBound() ) / ( GetUpperBound() - GetLowerBound() ); + return (value - GetLowerBound()) / (GetUpperBound() - GetLowerBound()); } -float Slider::MapBounds( float percent, float lowerBound, float upperBound ) +float Slider::MapBounds(float percent, float lowerBound, float upperBound) { - return lowerBound + percent * ( upperBound - lowerBound ); + return lowerBound + percent * (upperBound - lowerBound); } -Slider::Domain Slider::CalcDomain( const Vector2& currentSize ) +Slider::Domain Slider::CalcDomain(const Vector2& currentSize) { - return Domain( Vector2( 0.0f, 0.0f ), currentSize ); + return Domain(Vector2(0.0f, 0.0f), currentSize); } -void Slider::DisplayValue( float value, bool raiseSignals ) +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 ); + float x = mDomain.from.x + percent * (mDomain.to.x - mDomain.from.x); - mHandle.SetX( x ); + mHandle.SetProperty(Actor::Property::POSITION_X, x); // Progress bar - if( mProgress ) + if(mProgress) { - mProgress.SetSize( x, GetBackingRegion().y ); + mProgress.SetProperty(Actor::Property::SIZE, Vector2(x, GetTrackRegion().y)); } // Signals - if( raiseSignals ) + if(raiseSignals) { - Toolkit::Slider self = Toolkit::Slider::DownCast( Self() ); - mValueChangedSignal.Emit( self, clampledValue ); + Toolkit::Slider self = Toolkit::Slider::DownCast(Self()); + mValueChangedSignal.Emit(self, clampedValue); int markIndex; - if( MarkReached( percent, markIndex ) ) + if(MarkReached(percent, markIndex)) { - mMarkSignal.Emit( self, markIndex ); + mMarkReachedSignal.Emit(self, markIndex); } } - if( mHandleValueTextLabel ) + if(mHandleValueTextLabel) { std::stringstream ss; - ss.precision( GetValuePrecision() ); - ss << std::fixed << clampledValue; + ss.precision(GetValuePrecision()); + ss << std::fixed << clampedValue; - mHandleValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() ); + 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 ) +void Slider::SetMarks(const MarkList& marks) { mMarks = marks; } @@ -362,7 +373,7 @@ const Slider::MarkList& Slider::GetMarks() const return mMarks; } -void Slider::SetSnapToMarks( bool snap ) +void Slider::SetSnapToMarks(bool snap) { mSnapToMarks = snap; } @@ -375,110 +386,207 @@ bool Slider::GetSnapToMarks() const Actor Slider::CreateHitRegion() { Actor hitRegion = Actor::New(); - hitRegion.SetParentOrigin( ParentOrigin::CENTER ); - hitRegion.SetAnchorPoint( AnchorPoint::CENTER ); - hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent ); + hitRegion.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + hitRegion.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + hitRegion.TouchedSignal().Connect(this, &Slider::OnTouch); return hitRegion; } -Toolkit::ImageView Slider::CreateBacking() +Toolkit::ImageView Slider::CreateTrack() { - Toolkit::ImageView backing = Toolkit::ImageView::New(); - backing.SetParentOrigin( ParentOrigin::CENTER ); - backing.SetAnchorPoint( AnchorPoint::CENTER ); + Toolkit::ImageView track = Toolkit::ImageView::New(); + track.SetProperty(Dali::Actor::Property::NAME, "SliderTrack"); + track.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + track.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + return track; +} - return backing; +void Slider::SetTrackVisual(const std::string& filename) +{ + if(mHandle && (filename.size() > 0)) + { + mTrack.SetImage(filename); + mTrackVisual = filename; + } } -void Slider::SetBackingImageName( const std::string& imageName ) +void Slider::SetTrackVisual(Property::Map map) { - if( mBacking && ( imageName.size() > 0 ) ) + Property::Value* imageValue = map.Find("url"); + if(imageValue) + { + 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) { - mBacking.SetImage( imageName ); - mBackingImageName = imageName; + Vector2 size; + if(sizeValue->Get(size)) + { + mTrackRegion = size; + if(mTrack) + { + mTrack.SetProperty(Actor::Property::SIZE, mTrackRegion); + } + + ResizeProgressRegion(Vector2(0.0f, mTrackRegion.y)); + + mDomain = CalcDomain(mTrackRegion); + + // Set the progress bar to correct width + DisplayValue(GetValue(), false); + } } } -std::string Slider::GetBackingImageName() +std::string Slider::GetTrackVisual() { - return mBackingImageName; + return mTrackVisual; } Toolkit::ImageView Slider::CreateProgress() { Toolkit::ImageView progress = Toolkit::ImageView::New(); - progress.SetParentOrigin( ParentOrigin::CENTER_LEFT ); - progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT ); + progress.SetProperty(Dali::Actor::Property::NAME, "SliderProgress"); + progress.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT); + progress.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT); return progress; } -void Slider::SetProgressImageName( const std::string& imageName ) +void Slider::SetProgressVisual(const std::string& filename) { - if( mProgress && ( imageName.size() > 0 ) ) + if(mProgress && (filename.size() > 0)) { - mProgress.SetImage( imageName ); - mProgressImageName = imageName; + mProgress.SetImage(filename); + mProgressVisual = filename; } } -std::string Slider::GetProgressImageName() +void Slider::SetProgressVisual(Property::Map map) { - return mProgressImageName; + Property::Value* imageValue = map.Find("url"); + if(imageValue) + { + mProgressVisual.clear(); + std::string filename; + if(imageValue->Get(filename)) + { + if(mProgress && (filename.size() > 0)) + { + mProgress.SetImage(filename); + mProgressMap = map; + } + } + } } -void Slider::SetPopupImageName( const std::string& imageName ) +std::string Slider::GetProgressVisual() { - mPopupImageName = imageName; + return mProgressVisual; } -std::string Slider::GetPopupImageName() +void Slider::SetPopupVisual(const std::string& filename) { - return mPopupImageName; + mPopupVisual = filename; } -void Slider::CreatePopupImage( const std::string& imageName ) +void Slider::SetPopupVisual(Property::Map map) { - if( mPopup && ( imageName.size() > 0 ) ) + Property::Value* imageValue = map.Find("url"); + if(imageValue) { - Image image = ResourceImage::New( imageName ); - mPopup.SetImage( image ); + mPopupVisual.clear(); + std::string filename; + if(imageValue->Get(filename)) + { + if(mPopup && (filename.size() > 0)) + { + mPopup.SetImage(filename); + mPopupMap = map; + } + } } } -void Slider::SetPopupArrowImageName( const std::string& imageName ) +std::string Slider::GetPopupVisual() { - mPopupArrowImageName = imageName; + return mPopupVisual; } -std::string Slider::GetPopupArrowImageName() +void Slider::CreatePopupImage(const std::string& filename) { - return mPopupArrowImageName; + if(mPopup && (filename.size() > 0)) + { + Property::Map map; + map[Toolkit::ImageVisual::Property::URL] = filename; + mPopup.SetProperty(Toolkit::ImageView::Property::IMAGE, map); + } +} + +void Slider::SetPopupArrowVisual(const std::string& filename) +{ + mPopupArrowVisual = filename; } -void Slider::CreatePopupArrowImage( const std::string& imageName ) +void Slider::SetPopupArrowVisual(Property::Map map) { - if( mPopupArrow && ( imageName.size() > 0 ) ) + Property::Value* imageValue = map.Find("url"); + if(imageValue) { - Image image = ResourceImage::New( imageName ); - mPopupArrow.SetImage( image ); + 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& filename) +{ + if(mPopupArrow && (filename.size() > 0)) + { + Property::Map map; + map[Toolkit::ImageVisual::Property::URL] = filename; + mPopupArrow.SetProperty(Toolkit::ImageView::Property::IMAGE, map); } } -void Slider::ResizeProgressRegion( const Vector2& region ) +void Slider::ResizeProgressRegion(const Vector2& region) { - if( mProgress ) + if(mProgress) { - mProgress.SetSize( region ); + mProgress.SetProperty(Actor::Property::SIZE, region); } } Toolkit::ImageView Slider::CreateHandle() { Toolkit::ImageView handle = Toolkit::ImageView::New(); - handle.SetParentOrigin( ParentOrigin::CENTER_LEFT ); - handle.SetAnchorPoint( AnchorPoint::CENTER ); + handle.SetProperty(Dali::Actor::Property::NAME, "SliderHandle"); + handle.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT); + handle.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); return handle; } @@ -486,8 +594,10 @@ Toolkit::ImageView Slider::CreateHandle() Toolkit::ImageView Slider::CreatePopupArrow() { Toolkit::ImageView arrow = Toolkit::ImageView::New(); - arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER ); - arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER ); + arrow.SetStyleName("SliderPopupArrow"); + arrow.SetProperty(Dali::Actor::Property::NAME, "SliderPopupArrow"); + arrow.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER); + arrow.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER); return arrow; } @@ -495,61 +605,100 @@ Toolkit::ImageView Slider::CreatePopupArrow() Toolkit::TextLabel Slider::CreatePopupText() { Toolkit::TextLabel textLabel = Toolkit::TextLabel::New(); - 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.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, DEFAULT_POPUP_TEXT_COLOR ); - textLabel.SetPadding( Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) ); + textLabel.SetProperty(Dali::Actor::Property::NAME, "SliderPopupTextLabel"); + textLabel.SetStyleName("SliderPopupTextLabel"); + textLabel.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + textLabel.SetProperty(Actor::Property::ANCHOR_POINT, 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.SetProperty(Actor::Property::PADDING, Padding(POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f)); + textLabel.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false); return textLabel; } Toolkit::ImageView Slider::CreatePopup() { Toolkit::ImageView popup = Toolkit::ImageView::New(); - popup.SetParentOrigin( ParentOrigin::TOP_CENTER ); - popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER ); - popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH ); + popup.SetProperty(Dali::Actor::Property::NAME, "SliderPopup"); + popup.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER); + popup.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER); + popup.SetResizePolicy(ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH); mValueTextLabel = CreatePopupText(); - popup.Add( mValueTextLabel ); + popup.Add(mValueTextLabel); return popup; } -void Slider::SetHandleImageName( const std::string& imageName ) +void Slider::SetHandleVisual(const std::string& filename) { - if( mHandle && ( imageName.size() > 0 ) ) + if(mHandle && (filename.size() > 0)) { - mHandle.SetImage( imageName ); - mHandleImageName = imageName; + mHandle.SetImage(filename); + mHandleVisual = filename; } } -std::string Slider::GetHandleImageName() +void Slider::SetHandleVisual(Property::Map map) { - return mHandleImageName; + Property::Value* imageValue = map.Find("url"); + if(imageValue) + { + mHandleVisual.clear(); + std::string filename; + if(imageValue->Get(filename)) + { + if(mHandle && (filename.size() > 0)) + { + mHandle.SetImage(filename); + mHandleMap = map; + } + } + } + + 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); + } + } +} + +std::string Slider::GetHandleVisual() +{ + return mHandleVisual; } -void Slider::ResizeHandleRegion( const Vector2& region ) +void Slider::ResizeHandleSize(const Vector2& size) { - if( mHandle ) + if(mHandle) { - mHandle.SetSize( region ); + mHandle.SetProperty(Actor::Property::SIZE, size); } } void Slider::CreateHandleValueDisplay() { - if( mHandle && !mHandleValueTextLabel ) + if(mHandle && !mHandleValueTextLabel) { mHandleValueTextLabel = Toolkit::TextLabel::New(); - 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 ); + mHandleValueTextLabel.SetProperty(Dali::Actor::Property::NAME, "SliderHandleTextLabel"); + mHandleValueTextLabel.SetStyleName("SliderHandleTextLabel"); + mHandleValueTextLabel.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + mHandleValueTextLabel.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + mHandleValueTextLabel.SetProperty(Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER"); + mHandleValueTextLabel.SetProperty(Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER"); + mHandleValueTextLabel.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false); + mHandle.Add(mHandleValueTextLabel); } } @@ -558,23 +707,18 @@ void Slider::DestroyHandleValueDisplay() UnparentAndReset(mHandleValueTextLabel); } -void Slider::SetPopupTextColor( const Vector4& color ) -{ - mPopupTextColor = color; -} - Actor Slider::CreateValueDisplay() { Actor popup = Actor::New(); - popup.SetParentOrigin( ParentOrigin::TOP_CENTER ); - popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER ); + popup.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER); + popup.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER); mPopupArrow = CreatePopupArrow(); - popup.Add( mPopupArrow ); + popup.Add(mPopupArrow); mPopup = CreatePopup(); - mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT ); - mPopupArrow.Add( mPopup ); + mPopup.SetProperty(Actor::Property::SIZE, Vector2(0.0f, VALUE_POPUP_HEIGHT)); + mPopupArrow.Add(mPopup); return popup; } @@ -589,28 +733,28 @@ Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal() return mSlidingFinishedSignal; } -Toolkit::Slider::MarkSignalType& Slider::MarkSignal() +Toolkit::Slider::MarkReachedSignalType& Slider::MarkReachedSignal() { - return mMarkSignal; + return mMarkReachedSignal; } void Slider::UpdateSkin() { - switch( mState ) + switch(mState) { case NORMAL: { - mBacking.SetColor( Color::WHITE ); - mHandle.SetColor( Color::WHITE ); - mProgress.SetColor( Color::WHITE ); + mTrack.SetProperty(Actor::Property::COLOR, Color::WHITE); + mHandle.SetProperty(Actor::Property::COLOR, Color::WHITE); + mProgress.SetProperty(Actor::Property::COLOR, Color::WHITE); break; } case DISABLED: { - Vector4 disableColor = GetDisableColor(); - mBacking.SetColor( disableColor ); - mHandle.SetColor( disableColor ); - mProgress.SetColor( disableColor ); + Vector4 disabledColor = GetDisabledColor(); + mTrack.SetProperty(Actor::Property::COLOR, disabledColor); + mHandle.SetProperty(Actor::Property::COLOR, disabledColor); + mProgress.SetProperty(Actor::Property::COLOR, disabledColor); break; } case PRESSED: @@ -629,32 +773,32 @@ void Slider::CreateChildren() Actor self = Self(); // Hit region - mHitArea = CreateHitRegion(); + mHitArea = CreateHitRegion(); mPanDetector = PanGestureDetector::New(); - mPanDetector.Attach( mHitArea ); - mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan ); - self.Add( mHitArea ); + mPanDetector.Attach(mHitArea); + 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(); - mProgress.Add( mHandle ); + mProgress.Add(mHandle); } -void Slider::SetHitRegion( const Vector2& size ) +void Slider::SetHitRegion(const Vector2& size) { mHitRegion = size; - if( mHitArea ) + if(mHitArea) { - mHitArea.SetSize( mHitRegion ); + mHitArea.SetProperty(Actor::Property::SIZE, mHitRegion); } } @@ -665,23 +809,23 @@ const Vector2& Slider::GetHitRegion() const void Slider::AddPopup() { - if( !mValueDisplay ) + if(!mValueDisplay) { mValueDisplay = CreateValueDisplay(); - mValueDisplay.SetVisible( false ); - mHandle.Add( mValueDisplay ); + mValueDisplay.SetProperty(Actor::Property::VISIBLE, 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 ); + mValueTimer = Timer::New(VALUE_VIEW_SHOW_DURATION); + mValueTimer.TickSignal().Connect(this, &Slider::HideValueView); } } void Slider::RemovePopup() { - if( mValueDisplay ) + if(mValueDisplay) { mPopup.Unparent(); mPopup.Reset(); @@ -692,47 +836,36 @@ void Slider::RemovePopup() mValueDisplay.Unparent(); mValueDisplay.Reset(); - mValueTimer.TickSignal().Disconnect( this, &Slider::HideValueView ); + mValueTimer.TickSignal().Disconnect(this, &Slider::HideValueView); mValueTimer.Reset(); } } - -float Slider::MarkFilter( float value ) +float Slider::MarkFilter(float value) { const float MARK_TOLERANCE = GetMarkTolerance(); - float mark; - for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i) - { - const Property::Value& propertyValue = mMarks[i]; - propertyValue.Get( mark ); - mark = MapValuePercentage( mark ); - - // If close to a mark, return the mark - if( fabsf( mark - value ) < MARK_TOLERANCE ) - { - return mark; - } - } + float mark = SnapToMark(value); + if(fabsf(mark - value) < MARK_TOLERANCE) + return mark; return value; } -float Slider::SnapToMark( float value ) +float Slider::SnapToMark(float value) { float closestMark = value; float closestDist = std::numeric_limits::max(); float mark; - for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i) + for(MarkList::SizeType i = 0; i < mMarks.Count(); ++i) { const Property::Value& propertyValue = mMarks[i]; - propertyValue.Get( mark ); - mark = MapValuePercentage( mark ); + propertyValue.Get(mark); + mark = MapValuePercentage(mark); - float dist = fabsf( mark - value ); - if( dist < closestDist ) + float dist = fabsf(mark - value); + if(dist < closestDist) { closestDist = dist; closestMark = mark; @@ -742,31 +875,31 @@ float Slider::SnapToMark( float value ) return closestMark; } -bool Slider::MarkReached( float value, int& outIndex ) +bool Slider::MarkReached(float value, int& outIndex) { const float MARK_TOLERANCE = GetMarkTolerance(); // Binary search int head = 0, tail = mMarks.Size() - 1; - int current; + int current; float mark; - while( head <= tail ) + while(head <= tail) { - current = head + ( tail - head ) / 2; + current = head + (tail - head) / 2; - const Property::Value& propertyValue = mMarks[ current ]; - propertyValue.Get( mark ); - mark = MapValuePercentage( mark ); + const Property::Value& propertyValue = mMarks[current]; + propertyValue.Get(mark); + mark = MapValuePercentage(mark); - if( fabsf( mark - value ) < MARK_TOLERANCE ) + if(fabsf(mark - value) < MARK_TOLERANCE) { outIndex = current; return true; } - if( value < mark ) + if(value < mark) { tail = current - 1; } @@ -781,18 +914,18 @@ bool Slider::MarkReached( float value, int& outIndex ) bool Slider::HideValueView() { - if( mValueDisplay ) + if(mValueDisplay) { - mValueDisplay.SetVisible( false ); + mValueDisplay.SetProperty(Actor::Property::VISIBLE, false); } return false; } -void Slider::SetLowerBound( float bound ) +void Slider::SetLowerBound(float bound) { mLowerBound = bound; - DisplayValue( GetValue(), false ); + DisplayValue(GetValue(), false); } float Slider::GetLowerBound() const @@ -800,10 +933,10 @@ float Slider::GetLowerBound() const return mLowerBound; } -void Slider::SetUpperBound( float bound ) +void Slider::SetUpperBound(float bound) { mUpperBound = bound; - DisplayValue( GetValue(), false ); + DisplayValue(GetValue(), false); } float Slider::GetUpperBound() const @@ -811,10 +944,14 @@ float Slider::GetUpperBound() const return mUpperBound; } -void Slider::SetValue( float value ) +void Slider::SetValue(float value) { mValue = value; - DisplayValue( mValue, true ); + DisplayValue(mValue, true); + if(Self() == Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor()) + { + Control::Impl::GetAccessibilityObject(Self())->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE); + } } float Slider::GetValue() const @@ -822,61 +959,56 @@ 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.SetProperty(Actor::Property::SIZE, 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 + 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; - SetHitRegion( hitRegion ); + 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 ) +void Slider::SetValuePrecision(int precision) { mValuePrecision = precision; } @@ -886,12 +1018,12 @@ int Slider::GetValuePrecision() const return mValuePrecision; } -void Slider::SetShowPopup( bool showPopup ) +void Slider::SetShowPopup(bool showPopup) { mShowPopup = showPopup; // Value display - if( mShowPopup ) + if(mShowPopup) { AddPopup(); } @@ -906,11 +1038,11 @@ bool Slider::GetShowPopup() const return mShowPopup; } -void Slider::SetShowValue( bool showValue ) +void Slider::SetShowValue(bool showValue) { mShowValue = showValue; - if( mShowValue ) + if(mShowValue) { CreateHandleValueDisplay(); } @@ -925,9 +1057,9 @@ bool Slider::GetShowValue() const return mShowValue; } -void Slider::SetEnabled( bool enabled ) +void Slider::SetEnabled(bool enabled) { - if( enabled ) + if(enabled) { mState = NORMAL; } @@ -944,7 +1076,7 @@ bool Slider::IsEnabled() const return mState != DISABLED; } -void Slider::SetMarkTolerance( float tolerance ) +void Slider::SetMarkTolerance(float tolerance) { mMarkTolerance = tolerance; } @@ -955,20 +1087,20 @@ float Slider::GetMarkTolerance() const } // Static class method to support script connecting signals -bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ) +bool Slider::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor) { - Dali::BaseHandle handle( object ); + Dali::BaseHandle handle(object); - bool connected = true; - Toolkit::Slider slider = Toolkit::Slider::DownCast( handle ); + bool connected = true; + Toolkit::Slider slider = Toolkit::Slider::DownCast(handle); - if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) ) + if(0 == strcmp(signalName.c_str(), SIGNAL_VALUE_CHANGED)) { - slider.ValueChangedSignal().Connect( tracker, functor ); + slider.ValueChangedSignal().Connect(tracker, functor); } - else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) ) + else if(0 == strcmp(signalName.c_str(), SIGNAL_MARK)) { - slider.MarkSignal().Connect( tracker, functor ); + slider.MarkReachedSignal().Connect(tracker, functor); } else { @@ -979,169 +1111,167 @@ bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tr return connected; } -void Slider::DisplayPopup( float value ) +void Slider::DisplayPopup(float value) { // Value displayDoConnectSignal - if( mValueTextLabel ) + if(mValueTextLabel) { std::stringstream ss; - ss.precision( GetValuePrecision() ); + ss.precision(GetValuePrecision()); ss << std::fixed << value; - mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() ); + mValueTextLabel.SetProperty(Toolkit::TextLabel::Property::TEXT, ss.str()); - if( mValueDisplay ) + if(mValueDisplay) { - mValueDisplay.SetVisible( true ); + mValueDisplay.SetProperty(Actor::Property::VISIBLE, true); - mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION ); + mValueTimer.SetInterval(VALUE_VIEW_SHOW_DURATION); } } } -void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value ) +void Slider::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value) { - Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) ); + Toolkit::Slider slider = Toolkit::Slider::DownCast(Dali::BaseHandle(object)); - if ( slider ) + if(slider) { - Slider& sliderImpl( GetImpl( slider ) ); + Slider& sliderImpl(GetImpl(slider)); - switch ( propertyIndex ) + switch(propertyIndex) { case Toolkit::Slider::Property::LOWER_BOUND: { - sliderImpl.SetLowerBound( value.Get< float >() ); + sliderImpl.SetLowerBound(value.Get()); break; } case Toolkit::Slider::Property::UPPER_BOUND: { - sliderImpl.SetUpperBound( value.Get< float >() ); + sliderImpl.SetUpperBound(value.Get()); break; } case Toolkit::Slider::Property::VALUE: { - sliderImpl.SetValue( value.Get< float >() ); + sliderImpl.SetValue(value.Get()); break; } - case Toolkit::Slider::Property::HIT_REGION: + case Toolkit::Slider::Property::TRACK_VISUAL: { - sliderImpl.SetHitRegion( value.Get< Vector2 >() ); - break; - } - - case Toolkit::Slider::Property::BACKING_REGION: - { - sliderImpl.SetBackingRegion( value.Get< Vector2 >() ); - break; - } - - case Toolkit::Slider::Property::HANDLE_REGION: - { - sliderImpl.SetHandleRegion( value.Get< Vector2 >() ); + Property::Map map; + if(value.Get(map)) + { + sliderImpl.SetTrackVisual(map); + } break; } - case Toolkit::Slider::Property::BACKING_IMAGE_NAME: + 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::Property::HANDLE_IMAGE_NAME: + 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::Property::PROGRESS_IMAGE_NAME: + 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::Property::POPUP_IMAGE_NAME: - { - 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::Property::POPUP_ARROW_IMAGE_NAME: - { - sliderImpl.SetPopupArrowImageName( value.Get< std::string >() ); break; } - case Toolkit::Slider::Property::DISABLE_COLOR: + 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::Property::POPUP_TEXT_COLOR: + case Toolkit::Slider::Property::DISABLED_COLOR: { - sliderImpl.SetPopupTextColor( value.Get< Vector4 >() ); + sliderImpl.SetDisabledColor(value.Get()); break; } case Toolkit::Slider::Property::VALUE_PRECISION: { - sliderImpl.SetValuePrecision( value.Get< int >() ); + sliderImpl.SetValuePrecision(value.Get()); break; } case Toolkit::Slider::Property::SHOW_POPUP: { - sliderImpl.SetShowPopup( value.Get< bool >() ); + sliderImpl.SetShowPopup(value.Get()); break; } case Toolkit::Slider::Property::SHOW_VALUE: { - sliderImpl.SetShowValue( value.Get< bool >() ); - break; - } - - case Toolkit::Slider::Property::ENABLED: - { - sliderImpl.SetEnabled( value.Get< bool >() ); + sliderImpl.SetShowValue(value.Get()); break; } case Toolkit::Slider::Property::MARKS: { - sliderImpl.SetMarks( value.Get< Property::Array >() ); + sliderImpl.SetMarks(value.Get()); break; } case Toolkit::Slider::Property::SNAP_TO_MARKS: { - sliderImpl.SetSnapToMarks( value.Get< bool >() ); + sliderImpl.SetSnapToMarks(value.Get()); break; } case Toolkit::Slider::Property::MARK_TOLERANCE: { - sliderImpl.SetMarkTolerance( value.Get< float >() ); + sliderImpl.SetMarkTolerance(value.Get()); break; } } } } -Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex ) +Property::Value Slider::GetProperty(BaseObject* object, Property::Index propertyIndex) { Property::Value value; - Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) ); + Toolkit::Slider slider = Toolkit::Slider::DownCast(Dali::BaseHandle(object)); - if ( slider ) + if(slider) { - Slider& sliderImpl( GetImpl( slider ) ); + Slider& sliderImpl(GetImpl(slider)); - switch ( propertyIndex ) + switch(propertyIndex) { case Toolkit::Slider::Property::LOWER_BOUND: { @@ -1161,63 +1291,74 @@ Property::Value Slider::GetProperty( BaseObject* object, Property::Index propert break; } - case Toolkit::Slider::Property::HIT_REGION: - { - value = sliderImpl.GetHitRegion(); - break; - } - - case Toolkit::Slider::Property::BACKING_REGION: - { - value = sliderImpl.GetBackingRegion(); - break; - } - - case Toolkit::Slider::Property::HANDLE_REGION: + case Toolkit::Slider::Property::TRACK_VISUAL: { - value = sliderImpl.GetHandleRegion(); - break; - } - - case Toolkit::Slider::Property::BACKING_IMAGE_NAME: - { - value = sliderImpl.GetBackingImageName(); - break; - } - - case Toolkit::Slider::Property::HANDLE_IMAGE_NAME: - { - value = sliderImpl.GetHandleImageName(); + if(!sliderImpl.mTrackVisual.empty()) + { + value = sliderImpl.GetTrackVisual(); + } + else if(!sliderImpl.mTrackMap.Empty()) + { + value = sliderImpl.mTrackMap; + } break; } - case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME: + 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::Property::POPUP_IMAGE_NAME: + 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::Property::POPUP_ARROW_IMAGE_NAME: + 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::Property::DISABLE_COLOR: + 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::Property::POPUP_TEXT_COLOR: + case Toolkit::Slider::Property::DISABLED_COLOR: { - value = sliderImpl.GetPopupTextColor(); + value = sliderImpl.GetDisabledColor(); break; } @@ -1239,16 +1380,17 @@ Property::Value Slider::GetProperty( BaseObject* object, Property::Index propert break; } - case Toolkit::Slider::Property::ENABLED: - { - value = sliderImpl.IsEnabled(); - break; - } - case Toolkit::Slider::Property::MARKS: { - // TODO: Need to be able to return a PropertyArray - // value = sliderImpl.GetMarks(); + Property::Value value1(Property::ARRAY); + Property::Array* markArray = value1.GetArray(); + + if(markArray) + { + *markArray = sliderImpl.GetMarks(); + } + + value = value1; break; } @@ -1269,6 +1411,87 @@ Property::Value Slider::GetProperty( BaseObject* object, Property::Index propert return value; } +double Slider::AccessibleImpl::GetMinimum() +{ + auto self = Toolkit::Slider::DownCast(Self()); + return self.GetProperty(Toolkit::Slider::Property::LOWER_BOUND).Get(); +} + +double Slider::AccessibleImpl::GetCurrent() +{ + auto self = Toolkit::Slider::DownCast(Self()); + return self.GetProperty(Toolkit::Slider::Property::VALUE).Get(); +} + +double Slider::AccessibleImpl::GetMaximum() +{ + auto self = Toolkit::Slider::DownCast(Self()); + return self.GetProperty(Toolkit::Slider::Property::UPPER_BOUND).Get(); +} + +bool Slider::AccessibleImpl::SetCurrent(double current) +{ + if(current < GetMinimum() || current > GetMaximum()) + return false; + + auto self = Toolkit::Slider::DownCast(Self()); + auto& impl = Toolkit::GetImpl(self); + + const float prev = self.GetProperty(Toolkit::Slider::Property::VALUE); + float next = static_cast(current); + + if(fabsf(next - prev) < Math::MACHINE_EPSILON_0) + { + // do nothing + } + else if(self.GetProperty(Toolkit::Slider::Property::SNAP_TO_MARKS)) + { + auto marks = self.GetProperty(Toolkit::Slider::Property::MARKS); + + int prevIdx; + if(impl.MarkReached(impl.MapValuePercentage(prev), prevIdx)) + { + int nextIdx = prevIdx; + nextIdx += (next > prev) ? 1 : -1; + + if(nextIdx < 0 || nextIdx >= static_cast(marks.Count())) + { + return false; + } + + next = marks[nextIdx].Get(); + } + else + { + next = impl.MapBounds(impl.SnapToMark(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound()); + } + } + else + { + next = impl.MapBounds(impl.MarkFilter(impl.MapValuePercentage(next)), impl.GetLowerBound(), impl.GetUpperBound()); + } + + impl.SetValue(next); + impl.DisplayPopup(next); + + return true; +} + +double Slider::AccessibleImpl::GetMinimumIncrement() +{ + auto self = Toolkit::Slider::DownCast(Self()); + + bool hasMarks = !self.GetProperty(Toolkit::Slider::Property::MARKS).Empty(); + float tolerance = self.GetProperty(Toolkit::Slider::Property::MARK_TOLERANCE); + + if(!hasMarks || fabsf(tolerance) < 0.01) + { + return 0.0; // let screen-reader choose the increment + } + + return Math::MACHINE_EPSILON_10000 + tolerance * (GetMaximum() - GetMinimum()); +} + } // namespace Internal } // namespace Toolkit