X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fslider%2Fslider-impl.cpp;h=489e2048712fc8ff08ba254a0a70a87f229b5383;hb=09502f5f09f1294ef5555e4efbf0e7e8115bfbc3;hp=e90c6948b08acf393fe9ccdd102d2a5a90e0ab7c;hpb=2f39909cd5a858fe940936258ee6f558073d33f0;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git 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 e90c694..e2dc5e3 --- a/dali-toolkit/internal/controls/slider/slider-impl.cpp +++ b/dali-toolkit/internal/controls/slider/slider-impl.cpp @@ -1,26 +1,38 @@ -// -// Copyright (c) 2014 Samsung Electronics Co., Ltd. -// -// Licensed under the Flora License, Version 1.0 (the License); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://floralicense.org/license/ -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an AS IS BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - +/* + * Copyright (c) 2020 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER #include -#include +// EXTERNAL INCLUDES +#include // for strcmp #include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include +#include +#include +#include using namespace Dali; -using namespace std; namespace Dali { @@ -31,14 +43,37 @@ namespace Toolkit namespace Internal { -namespace +namespace // Unnamed 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) + +BaseHandle Create() +{ + return Dali::Toolkit::Slider::New(); +} + +// 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, "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() const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width @@ -51,28 +86,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.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.png"; -const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.png"; -const char* SKINNED_POPUP_ARROW_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup-arrow.png"; - -const Vector4 SKINNED_BACKING_SCALE9_BORDER( 12.0f, 0.0f, 12.0f, 0.0f ); -const Vector4 SKINNED_PROGRESS_SCALE9_BORDER( 14.0f, 0.0f, 0.0f, 0.0f ); -const Vector4 SKINNED_POPUP_SCALE9_BORDER( 10.0f, 10.0f, 10.0f, 10.0f ); +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_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; @@ -81,19 +111,9 @@ 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; - -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 ); - -} // namespace +} // Unnamed namespace /////////////////////////////////////////////////////////////////////////////////////////////////// // Slider @@ -115,8 +135,29 @@ Dali::Toolkit::Slider Slider::New() } Slider::Slider() -: ControlImpl( true ), - mState( NORMAL ) +: 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 ) { } @@ -132,126 +173,112 @@ void Slider::OnInitialize() // Properties Actor self = Self(); - // Register properties in a block so the properties are ready for the update functions - mPropertyHitRegion = self.RegisterProperty( Dali::Toolkit::Slider::HIT_REGION_PROPERTY_NAME, DEFAULT_HIT_REGION, Property::READ_WRITE ); - mPropertyBackingRegion = self.RegisterProperty( Dali::Toolkit::Slider::BACKING_REGION_PROPERTY_NAME, DEFAULT_BACKING_REGION, Property::READ_WRITE ); - mPropertyHandleRegion = self.RegisterProperty( Dali::Toolkit::Slider::HANDLE_REGION_PROPERTY_NAME, DEFAULT_HANDLE_REGION, Property::READ_WRITE ); - - mPropertyBackingImageName = self.RegisterProperty( Dali::Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY_NAME, SKINNED_BACKING_IMAGE_NAME, Property::READ_WRITE ); - mPropertyHandleImageName = self.RegisterProperty( Dali::Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY_NAME, SKINNED_HANDLE_IMAGE_NAME, Property::READ_WRITE ); - - mPropertyProgressImageName = self.RegisterProperty( Dali::Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY_NAME, SKINNED_PROGRESS_IMAGE_NAME, Property::READ_WRITE ); - mPropertyPopupImageName = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY_NAME, SKINNED_POPUP_IMAGE_NAME, Property::READ_WRITE ); - mPropertyPopupArrowImageName = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY_NAME, SKINNED_POPUP_ARROW_IMAGE_NAME, Property::READ_WRITE ); - - mPropertyBackingScale9Border = self.RegisterProperty( Dali::Toolkit::Slider::BACKING_SCALE9_BORDER_PROPERTY_NAME, SKINNED_BACKING_SCALE9_BORDER, Property::READ_WRITE ); - mPropertyProgressScale9Border = self.RegisterProperty( Dali::Toolkit::Slider::PROGRESS_SCALE9_BORDER_PROPERTY_NAME, SKINNED_PROGRESS_SCALE9_BORDER, Property::READ_WRITE ); - mPropertyPopupScale9Border = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_SCALE9_BORDER_PROPERTY_NAME, SKINNED_POPUP_SCALE9_BORDER, Property::READ_WRITE ); - - mPropertyDisableColor = self.RegisterProperty( Dali::Toolkit::Slider::DISABLE_COLOR_PROPERTY_NAME, DEFAULT_DISABLE_COLOR, Property::READ_WRITE ); - mPropertyPopupTextColor = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY_NAME, DEFAULT_POPUP_TEXT_COLOR, Property::READ_WRITE ); - - mPropertyValuePrecision = self.RegisterProperty( Dali::Toolkit::Slider::VALUE_PRECISION_PROPERTY_NAME, DEFAULT_VALUE_PRECISION, Property::READ_WRITE ); - mPropertyShowPopup = self.RegisterProperty( Dali::Toolkit::Slider::SHOW_POPUP_PROPERTY_NAME, DEFAULT_SHOW_POPUP, Property::READ_WRITE ); - mPropertyShowValue = self.RegisterProperty( Dali::Toolkit::Slider::SHOW_VALUE_PROPERTY_NAME, DEFAULT_SHOW_VALUE, Property::READ_WRITE ); - - mPropertyEnabled = self.RegisterProperty( Dali::Toolkit::Slider::ENABLED_PROPERTY_NAME, DEFAULT_ENABLED, Property::READ_WRITE ); - - mPropertyMarks = self.RegisterProperty( Dali::Toolkit::Slider::MARKS_PROPERTY_NAME, mMarks, Property::READ_WRITE ); - mPropertySnapToMarks = self.RegisterProperty( Dali::Toolkit::Slider::SNAP_TO_MARKS_PROPERTY_NAME, false, Property::READ_WRITE ); - mPropertyMarkTolerance = self.RegisterProperty( Dali::Toolkit::Slider::MARK_TOLERANCE_PROPERTY_NAME, MARK_SNAP_TOLERANCE, Property::READ_WRITE ); - - mPropertyLowerBound = self.RegisterProperty( Dali::Toolkit::Slider::LOWER_BOUND_PROPERTY_NAME, DEFAULT_LOWER_BOUND, Property::READ_WRITE ); - mPropertyUpperBound = self.RegisterProperty( Dali::Toolkit::Slider::UPPER_BOUND_PROPERTY_NAME, DEFAULT_UPPER_BOUND, Property::READ_WRITE ); - mPropertyValue = self.RegisterProperty( Dali::Toolkit::Slider::VALUE_PROPERTY_NAME, DEFAULT_VALUE, Property::READ_WRITE ); - - ResizeHitRegion( DEFAULT_HIT_REGION ); - SetBackingRegion( DEFAULT_BACKING_REGION ); - UpdateHandleRegion( DEFAULT_HANDLE_REGION ); - CreateBackingImage( SKINNED_BACKING_IMAGE_NAME ); - CreateHandleImage( SKINNED_HANDLE_IMAGE_NAME ); - CreateProgressImage( SKINNED_PROGRESS_IMAGE_NAME ); - CreatePopupImage( SKINNED_POPUP_IMAGE_NAME ); - CreatePopupArrowImage( SKINNED_POPUP_ARROW_IMAGE_NAME ); - SetBackingScale9( SKINNED_BACKING_SCALE9_BORDER ); - SetProgressScale9( SKINNED_PROGRESS_SCALE9_BORDER ); - SetPopupScale9( SKINNED_POPUP_SCALE9_BORDER ); - UpdatePopupTextColor( DEFAULT_POPUP_TEXT_COLOR ); - ShowPopup( DEFAULT_SHOW_POPUP ); - ShowValue( DEFAULT_SHOW_VALUE ); + SetHitRegion( DEFAULT_HIT_REGION ); + SetTrackRegion( DEFAULT_TRACK_REGION ); + SetHandleSize( DEFAULT_HANDLE_SIZE ); + + 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 ); + SetEnabled( DEFAULT_ENABLED ); - UpdateLowerBound( DEFAULT_LOWER_BOUND ); - UpdateUpperBound( DEFAULT_UPPER_BOUND ); + SetDisabledColor( DEFAULT_DISABLED_COLOR ); + + SetSnapToMarks( DEFAULT_SNAP_TO_MARKS ); + SetMarkTolerance( MARK_SNAP_TOLERANCE ); + + SetLowerBound( DEFAULT_LOWER_BOUND ); + SetUpperBound( DEFAULT_UPPER_BOUND ); UpdateSkin(); - DisplayValue( DEFAULT_VALUE, false ); // Run this last to display the correct value + SetValuePrecision( DEFAULT_VALUE_PRECISION ); + mValue = DEFAULT_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< Dali::Accessibility::Accessible >( + new AccessibleImpl( actor, Dali::Accessibility::Role::SLIDER ) ); + } ); } -void Slider::OnControlSizeSet( 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 TouchEvent& 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 ) { mState = NORMAL; - mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), Self().GetProperty( mPropertyValue ).Get()); + mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() ); } } } - return true; + return false; } -void Slider::OnPan( Actor actor, PanGesture gesture ) +void Slider::OnPan( Actor actor, const PanGesture& gesture ) { // gesture.position is in local actor coordinates if( mState != DISABLED ) { - switch( gesture.state ) + switch( gesture.GetState() ) { - case Gesture::Continuing: + case GestureState::CONTINUING: { if( mState == PRESSED ) { - float value = MapBounds( MarkFilter ( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() ); + float value = MapBounds( MarkFilter ( MapPercentage( gesture.GetPosition() ) ), GetLowerBound(), GetUpperBound() ); SetValue( value ); DisplayPopup( value ); } break; } - case Gesture::Finished: + case GestureState::FINISHED: { if( mState == PRESSED ) { if( GetSnapToMarks() ) { - float value = MapBounds( SnapToMark( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() ); + float value = MapBounds( SnapToMark( MapPercentage( gesture.GetPosition() ) ), GetLowerBound(), GetUpperBound() ); SetValue( value ); DisplayPopup( value ); } - mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), Self().GetProperty( mPropertyValue ).Get()); + mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() ); } mState = NORMAL; @@ -296,60 +323,50 @@ 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.SetProperty( Actor::Property::POSITION_X, 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.SetProperty( Actor::Property::SIZE, Vector2( 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 ); } } - if( mHandleValueTextView ) + if( mHandleValueTextLabel ) { std::stringstream ss; ss.precision( GetValuePrecision() ); - ss << fixed << clampledValue; - mHandleValueTextView.SetText( ss.str() ); + ss << std::fixed << clampedValue; + + 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 ) { - float value; - for( MarkList::const_iterator it = marks.begin(), itEnd = marks.end(); it != itEnd; ++it ) - { - const Property::Value& propertyValue = *it; - propertyValue.Get( value ); - - mMarks.push_back( value ); - } + mMarks = marks; } const Slider::MarkList& Slider::GetMarks() const @@ -357,109 +374,203 @@ const Slider::MarkList& Slider::GetMarks() const return mMarks; } +void Slider::SetSnapToMarks( bool snap ) +{ + mSnapToMarks = snap; +} + bool Slider::GetSnapToMarks() const { - return Self().GetProperty( mPropertySnapToMarks ); + return mSnapToMarks; } 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; } -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.SetProperty( Dali::Actor::Property::NAME,"SliderTrack"); + track.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); + track.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER ); + return track; } -void Slider::CreateBackingImage( 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; } } -void Slider::SetBackingScale9( const Vector4& border ) +void Slider::SetTrackVisual( Property::Map map ) { - if( mBacking ) + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) { - mBacking.SetStyle( ImageActor::STYLE_NINE_PATCH ); - mBacking.SetNinePatchBorder( border ); + mTrackVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mTrack && ( filename.size() > 0 ) ) + { + mTrack.SetImage( filename ); + mTrackMap = map; + } + } } -} -void Slider::SetBackingRegionSize( const Vector2& region ) -{ - if( mBacking ) + Property::Value* sizeValue = map.Find( "size" ); + if( sizeValue ) { - mBacking.SetSize( region ); + 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 ); + } } } -ImageActor Slider::CreateProgress() +std::string Slider::GetTrackVisual() +{ + return mTrackVisual; +} + +Toolkit::ImageView Slider::CreateProgress() { - ImageActor progress = ImageActor::New(); - progress.SetParentOrigin( ParentOrigin::CENTER_LEFT ); - progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT ); - progress.SetZ( PROGRESS_Z ); + Toolkit::ImageView progress = Toolkit::ImageView::New(); + 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::CreateProgressImage( 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; } } -void Slider::CreatePopupImage( const std::string& imageName ) +void Slider::SetProgressVisual( Property::Map map ) { - if( mPopup && imageName != String::EMPTY ) + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) { - Image image = Image::New( imageName ); - mPopup.SetImage( image ); + mProgressVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mProgress && ( filename.size() > 0 ) ) + { + mProgress.SetImage( filename ); + mProgressMap = map; + } + } } } -void Slider::CreatePopupArrowImage( const std::string& imageName ) +std::string Slider::GetProgressVisual() +{ + return mProgressVisual; +} + +void Slider::SetPopupVisual( const std::string& filename ) +{ + mPopupVisual = filename; +} + +void Slider::SetPopupVisual( Property::Map map ) { - if( mPopupArrow && imageName != String::EMPTY ) + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) { - Image image = Image::New( imageName ); - mPopupArrow.SetImage( image ); + mPopupVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mPopup && ( filename.size() > 0 ) ) + { + mPopup.SetImage( filename ); + mPopupMap = map; + } + } } } -void Slider::SetProgressScale9( const Vector4& border ) +std::string Slider::GetPopupVisual() { - if( mProgress ) + return mPopupVisual; +} + +void Slider::CreatePopupImage( const std::string& filename ) +{ + if( mPopup && ( filename.size() > 0 ) ) { - mProgress.SetStyle( ImageActor::STYLE_NINE_PATCH ); - mProgress.SetNinePatchBorder( border ); + 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::SetPopupArrowVisual( Property::Map map ) +{ + 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; + } + } } } -void Slider::SetPopupScale9( const Vector4& border ) +std::string Slider::GetPopupArrowVisual() +{ + return mPopupArrowVisual; +} + +void Slider::CreatePopupArrowImage( const std::string& filename ) { - if( mPopup ) + if( mPopupArrow && ( filename.size() > 0 ) ) { - mPopup.SetStyle( ImageActor::STYLE_NINE_PATCH ); - mPopup.SetNinePatchBorder( border ); + Property::Map map; + map[Toolkit::ImageVisual::Property::URL] = filename; + mPopupArrow.SetProperty( Toolkit::ImageView::Property::IMAGE, map ); } } @@ -467,107 +578,147 @@ void Slider::ResizeProgressRegion( const Vector2& region ) { if( mProgress ) { - mProgress.SetSize( region ); + mProgress.SetProperty( Actor::Property::SIZE, region ); } } -ImageActor Slider::CreateHandle() +Toolkit::ImageView Slider::CreateHandle() { - ImageActor handle = ImageActor::New(); - handle.SetParentOrigin( ParentOrigin::CENTER_LEFT ); - handle.SetAnchorPoint( AnchorPoint::CENTER ); - handle.SetZ( HANDLE_Z ); + Toolkit::ImageView handle = Toolkit::ImageView::New(); + 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; } -ImageActor Slider::CreatePopupArrow() +Toolkit::ImageView Slider::CreatePopupArrow() { - ImageActor arrow = ImageActor::New(); - arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER ); - arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER ); - arrow.SetZ( HANDLE_Z ); + Toolkit::ImageView arrow = Toolkit::ImageView::New(); + 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; } -Toolkit::TextView Slider::CreatePopupText() +Toolkit::TextLabel Slider::CreatePopupText() { - Toolkit::TextView textView = Toolkit::TextView::New(); - textView.SetParentOrigin( ParentOrigin::CENTER ); - textView.SetAnchorPoint( AnchorPoint::CENTER ); - textView.SetSizePolicy( Control::Flexible, Control::Flexible ); - textView.SetZ( VALUE_DISPLAY_TEXT_Z ); - return textView; + Toolkit::TextLabel textLabel = Toolkit::TextLabel::New(); + 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; } -ImageActor Slider::CreatePopup() +Toolkit::ImageView Slider::CreatePopup() { - ImageActor popup = ImageActor::New(); - popup.SetParentOrigin( ParentOrigin::TOP_CENTER ); - popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER ); + Toolkit::ImageView popup = Toolkit::ImageView::New(); + 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 ); - mValueTextView = CreatePopupText(); - popup.Add( mValueTextView ); + mValueTextLabel = CreatePopupText(); + popup.Add( mValueTextLabel ); return popup; } -void Slider::CreateHandleImage( 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; } } -void Slider::ResizeHandleRegion( const Vector2& region ) +void Slider::SetHandleVisual( Property::Map map ) { - if( mHandle ) + Property::Value* imageValue = map.Find( "url" ); + if( imageValue ) { - mHandle.SetSize( region ); + mHandleVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mHandle && ( filename.size() > 0 ) ) + { + mHandle.SetImage( filename ); + mHandleMap = map; + } + } } -} -void Slider::CreateHandleValueDisplay() -{ - if( mHandle && !mHandleValueTextView ) + Property::Value* sizeValue = map.Find( "size" ); + if( sizeValue ) { - mHandleValueTextView = Toolkit::TextView::New(); - mHandleValueTextView.SetParentOrigin( ParentOrigin::CENTER ); - mHandleValueTextView.SetAnchorPoint( AnchorPoint::CENTER ); - mHandleValueTextView.SetSize( GetHandleRegion() ); - mHandleValueTextView.SetZ( HANDLE_VALUE_DISPLAY_TEXT_Z ); - mHandle.Add( mHandleValueTextView ); + Vector2 size; + if( sizeValue->Get( size ) ) + { + mHandleSize = size; + ResizeHandleSize( mHandleSize ); + + Vector2 hitRegion = GetHitRegion(); + hitRegion.x += mHandleSize.x; + SetHitRegion( hitRegion ); + } } } -void Slider::DestroyHandleValueDisplay() +std::string Slider::GetHandleVisual() { - mHandleValueTextView.Unparent(); - mHandleValueTextView.Reset(); + return mHandleVisual; +} + +void Slider::ResizeHandleSize( const Vector2& size ) +{ + if( mHandle ) + { + mHandle.SetProperty( Actor::Property::SIZE, size ); + } } -void Slider::UpdatePopupTextColor( const Vector4& color ) +void Slider::CreateHandleValueDisplay() { - if( mValueTextView ) + if( mHandle && !mHandleValueTextLabel ) { - mValueTextView.SetColor( color ); + mHandleValueTextLabel = Toolkit::TextLabel::New(); + 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 ); } } +void Slider::DestroyHandleValueDisplay() +{ + UnparentAndReset(mHandleValueTextLabel); +} + 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 ); mPopup = CreatePopup(); - mPopup.SetSize( 0.0f, VALUE_POPUP_HEIGHT ); + mPopup.SetProperty( Actor::Property::SIZE, Vector2( 0.0f, VALUE_POPUP_HEIGHT ) ); mPopupArrow.Add( mPopup ); return popup; @@ -583,9 +734,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() @@ -594,17 +745,17 @@ void Slider::UpdateSkin() { 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,39 +780,44 @@ 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::ResizeHitRegion( const Vector2& size ) +void Slider::SetHitRegion( const Vector2& size ) { + mHitRegion = size; + if( mHitArea ) { - mHitArea.SetSize( size ); + mHitArea.SetProperty( Actor::Property::SIZE, mHitRegion ); } } +const Vector2& Slider::GetHitRegion() const +{ + return mHitRegion; +} + void Slider::AddPopup() { if( !mValueDisplay ) { mValueDisplay = CreateValueDisplay(); - mValueDisplay.SetVisible( false ); + mValueDisplay.SetProperty( Actor::Property::VISIBLE, false ); mHandle.Add( mValueDisplay ); - Actor self = Self(); - CreatePopupImage( self.GetProperty( mPropertyPopupImageName ) ); - SetPopupScale9( GetPopupScale9Border() ); - CreatePopupArrowImage( self.GetProperty( mPropertyPopupArrowImageName ) ); + CreatePopupImage( GetPopupVisual() ); + CreatePopupArrowImage( GetPopupArrowVisual() ); mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION ); mValueTimer.TickSignal().Connect( this, &Slider::HideValueView ); @@ -691,19 +847,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 ) - { - const Property::Value& propertyValue = *it; - 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; } @@ -714,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 ); @@ -737,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; @@ -754,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; } } @@ -774,211 +918,114 @@ bool Slider::HideValueView() { if( mValueDisplay ) { - mValueDisplay.SetVisible( false ); + mValueDisplay.SetProperty( Actor::Property::VISIBLE, false ); } return false; } -void Slider::OnPropertySet( Property::Index index, Property::Value propertyValue ) -{ - if( index == mPropertyLowerBound ) - { - UpdateLowerBound( propertyValue.Get() ); - } - else if( index == mPropertyUpperBound ) - { - UpdateUpperBound( propertyValue.Get() ); - } - else if( index == mPropertyValue ) - { - DisplayValue( propertyValue.Get(), true ); - } - else if( index == mPropertyHitRegion ) - { - ResizeHitRegion( propertyValue.Get() ); - } - else if( index == mPropertyBackingRegion ) - { - ResizeBackingRegion( propertyValue.Get() ); - } - else if( index == mPropertyHandleRegion ) - { - UpdateHandleRegion( propertyValue.Get() ); - } - else if( index == mPropertyBackingImageName ) - { - CreateBackingImage( propertyValue.Get() ); - } - else if( index == mPropertyHandleImageName ) - { - CreateHandleImage( propertyValue.Get() ); - } - else if( index == mPropertyProgressImageName ) - { - CreateProgressImage( propertyValue.Get() ); - } - else if( index == mPropertyPopupImageName ) - { - CreatePopupImage( propertyValue.Get() ); - } - else if( index == mPropertyPopupArrowImageName ) - { - CreatePopupArrowImage( propertyValue.Get() ); - } - else if( index == mPropertyBackingScale9Border ) - { - SetBackingScale9( propertyValue.Get() ); - } - else if( index == mPropertyProgressScale9Border ) - { - SetProgressScale9( propertyValue.Get() ); - } - else if( index == mPropertyPopupScale9Border ) - { - SetPopupScale9( propertyValue.Get() ); - } - else if( index == mPropertyDisableColor ) - { - UpdateSkin(); - } - else if( index == mPropertyPopupTextColor ) - { - UpdatePopupTextColor( propertyValue.Get() ); - } - else if( index == mPropertyValuePrecision ) - { - DisplayValue( GetValue(), false ); - } - else if( index == mPropertyShowPopup ) - { - ShowPopup( propertyValue.Get() ); - } - else if( index == mPropertyShowValue ) - { - ShowValue( propertyValue.Get() ); - } - else if( index == mPropertyEnabled ) - { - SetEnabled( propertyValue.Get() ); - } - else if( index == mPropertyMarks ) - { - SetMarks( propertyValue.Get() ); - } - else if( index == mPropertySnapToMarks ) - { - // Nothing - } - else if( index == mPropertyMarkTolerance ) - { - // Nothing - } -} - -void Slider::UpdateLowerBound( float bound ) +void Slider::SetLowerBound( float bound ) { + mLowerBound = bound; DisplayValue( GetValue(), false ); } float Slider::GetLowerBound() const { - return Self().GetProperty( mPropertyLowerBound ); + return mLowerBound; } -void Slider::UpdateUpperBound( float bound ) +void Slider::SetUpperBound( float bound ) { + mUpperBound = bound; DisplayValue( GetValue(), false ); } float Slider::GetUpperBound() const { - return Self().GetProperty( mPropertyUpperBound ); + return mUpperBound; } void Slider::SetValue( float value ) { - Self().SetProperty( mPropertyValue, value ); + mValue = value; + DisplayValue( mValue, true ); + if (Self() == Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor()) + { + Control::Impl::GetAccessibilityObject(Self())->Emit(Dali::Accessibility::ObjectPropertyChangeEvent::VALUE); + } } float Slider::GetValue() const { - return Self().GetProperty( mPropertyValue ); + return mValue; } -void Slider::SetHitRegion( const Vector2& region ) +void Slider::SetTrackRegion( const Vector2& region ) { - Self().SetProperty( mPropertyHitRegion, region ); -} + mTrackRegion = region; -Vector2 Slider::GetHitRegion() const -{ - return Self().GetProperty( mPropertyHitRegion ); -} - -void Slider::SetBackingRegion( const Vector2& region ) -{ - Self().SetProperty( mPropertyBackingRegion, region ); -} + if( mTrack ) + { + mTrack.SetProperty( Actor::Property::SIZE, mTrackRegion ); + } -void Slider::ResizeBackingRegion( const Vector2& region ) -{ - SetBackingRegionSize( region ); - ResizeProgressRegion( Vector2( 0.0f, region.y ) ); + ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) ); - mDomain = CalcDomain( region ); + mDomain = CalcDomain( mTrackRegion ); DisplayValue( GetValue(), false ); // Set the progress bar to correct width } -Vector2 Slider::GetBackingRegion() const +const Vector2& Slider::GetTrackRegion() const { - return Self().GetProperty( mPropertyBackingRegion ); + return mTrackRegion; } -void Slider::UpdateHandleRegion( const Vector2& region ) +void Slider::SetHandleSize( const Vector2& size ) { - ResizeHandleRegion( region ); + mHandleSize = size; + + ResizeHandleSize( mHandleSize ); Vector2 hitRegion = GetHitRegion(); - hitRegion.x += region.x; + hitRegion.x += mHandleSize.x; SetHitRegion( hitRegion ); } -Vector2 Slider::GetHandleRegion() const +const Vector2& Slider::GetHandleSize() const { - return Self().GetProperty( mPropertyHandleRegion ); + return mHandleSize; } -Vector4 Slider::GetBackingScale9Border() const +void Slider::SetDisabledColor( const Vector4& color ) { - return Self().GetProperty( mPropertyBackingScale9Border ); -} + mDisabledColor = color; -Vector4 Slider::GetPopupScale9Border() const -{ - return Self().GetProperty( mPropertyPopupScale9Border ); + UpdateSkin(); } -Vector4 Slider::GetDisableColor() const +Vector4 Slider::GetDisabledColor() const { - return Self().GetProperty( mPropertyDisableColor ); + return mDisabledColor; } -Vector4 Slider::GetPopupTextColor() const +void Slider::SetValuePrecision( int precision ) { - return Self().GetProperty( mPropertyPopupTextColor ); + mValuePrecision = precision; } int Slider::GetValuePrecision() const { - return Self().GetProperty( mPropertyValuePrecision ); + return mValuePrecision; } -void Slider::ShowPopup( bool showPopup ) +void Slider::SetShowPopup( bool showPopup ) { + mShowPopup = showPopup; + // Value display - if( showPopup ) + if( mShowPopup ) { AddPopup(); } @@ -990,12 +1037,14 @@ void Slider::ShowPopup( bool showPopup ) bool Slider::GetShowPopup() const { - return Self().GetProperty( mPropertyShowPopup ); + return mShowPopup; } -void Slider::ShowValue( bool showValue ) +void Slider::SetShowValue( bool showValue ) { - if( showValue ) + mShowValue = showValue; + + if( mShowValue ) { CreateHandleValueDisplay(); } @@ -1007,7 +1056,7 @@ void Slider::ShowValue( bool showValue ) bool Slider::GetShowValue() const { - return Self().GetProperty( mPropertyShowValue ); + return mShowValue; } void Slider::SetEnabled( bool enabled ) @@ -1029,13 +1078,17 @@ bool Slider::IsEnabled() const return mState != DISABLED; } -float Slider::GetMarkTolerance() const +void Slider::SetMarkTolerance( float tolerance ) { - return Self().GetProperty( mPropertyMarkTolerance ); + mMarkTolerance = tolerance; } -// static class method to support script connecting signals +float Slider::GetMarkTolerance() const +{ + return mMarkTolerance; +} +// 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 ); @@ -1043,15 +1096,15 @@ 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 + else { // signalName does not match any signal connected = false; @@ -1062,34 +1115,380 @@ bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tr void Slider::DisplayPopup( float value ) { - // Value display - if( mValueTextView ) + // Value displayDoConnectSignal + if( mValueTextLabel ) { std::stringstream ss; ss.precision( GetValuePrecision() ); - ss << fixed << value; - mValueTextView.SetText( ss.str() ); - TextStyle style; - style.SetTextColor( GetPopupTextColor() ); - mValueTextView.SetStyleToCurrentText( style, TextStyle::COLOR); + ss << std::fixed << value; + mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() ); if( mValueDisplay ) { - Font font = Font::New(); - float popupWidth = font.MeasureText( ss.str() ).x + VALUE_POPUP_MARGIN * 2.0f; - if( popupWidth < VALUE_POPUP_MIN_WIDTH ) + mValueDisplay.SetProperty( Actor::Property::VISIBLE, true ); + + mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION ); + } + } +} + +void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value ) +{ + Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) ); + + if ( slider ) + { + Slider& sliderImpl( GetImpl( slider ) ); + + switch ( propertyIndex ) + { + case Toolkit::Slider::Property::LOWER_BOUND: { - popupWidth = VALUE_POPUP_MIN_WIDTH; + sliderImpl.SetLowerBound( value.Get< float >() ); + break; } - mPopup.SetSize( popupWidth, VALUE_POPUP_HEIGHT ); - mValueDisplay.SetVisible( true ); + case Toolkit::Slider::Property::UPPER_BOUND: + { + sliderImpl.SetUpperBound( value.Get< float >() ); + break; + } - mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION ); + case Toolkit::Slider::Property::VALUE: + { + sliderImpl.SetValue( value.Get< float >() ); + break; + } + + case Toolkit::Slider::Property::TRACK_VISUAL: + { + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetTrackVisual( map ); + } + break; + } + + case Toolkit::Slider::Property::HANDLE_VISUAL: + { + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetHandleVisual( map ); + } + break; + } + + case Toolkit::Slider::Property::PROGRESS_VISUAL: + { + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetProgressVisual( map ); + } + break; + } + + case Toolkit::Slider::Property::POPUP_VISUAL: + { + std::string imageUrl; + if( value.Get( imageUrl ) ) + { + sliderImpl.SetPopupVisual( imageUrl ); + } + + // 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 ); + } + + break; + } + + case Toolkit::Slider::Property::POPUP_ARROW_VISUAL: + { + Property::Map map; + if( value.Get( map ) ) + { + sliderImpl.SetPopupArrowVisual( map ); + } + break; + } + + case Toolkit::Slider::Property::DISABLED_COLOR: + { + sliderImpl.SetDisabledColor( value.Get< Vector4 >() ); + break; + } + + case Toolkit::Slider::Property::VALUE_PRECISION: + { + sliderImpl.SetValuePrecision( value.Get< int >() ); + break; + } + + case Toolkit::Slider::Property::SHOW_POPUP: + { + sliderImpl.SetShowPopup( value.Get< bool >() ); + break; + } + + case Toolkit::Slider::Property::SHOW_VALUE: + { + sliderImpl.SetShowValue( value.Get< bool >() ); + break; + } + + case Toolkit::Slider::Property::MARKS: + { + sliderImpl.SetMarks( value.Get< Property::Array >() ); + break; + } + + case Toolkit::Slider::Property::SNAP_TO_MARKS: + { + sliderImpl.SetSnapToMarks( value.Get< bool >() ); + break; + } + + case Toolkit::Slider::Property::MARK_TOLERANCE: + { + sliderImpl.SetMarkTolerance( value.Get< float >() ); + break; + } + } + } +} + +Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex ) +{ + Property::Value value; + + Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) ); + + if ( slider ) + { + Slider& sliderImpl( GetImpl( slider ) ); + + switch ( propertyIndex ) + { + case Toolkit::Slider::Property::LOWER_BOUND: + { + value = sliderImpl.GetLowerBound(); + break; + } + + case Toolkit::Slider::Property::UPPER_BOUND: + { + value = sliderImpl.GetUpperBound(); + break; + } + + case Toolkit::Slider::Property::VALUE: + { + value = sliderImpl.GetValue(); + break; + } + + case Toolkit::Slider::Property::TRACK_VISUAL: + { + if( !sliderImpl.mTrackVisual.empty() ) + { + value = sliderImpl.GetTrackVisual(); + } + else if( !sliderImpl.mTrackMap.Empty() ) + { + value = sliderImpl.mTrackMap; + } + break; + } + + case Toolkit::Slider::Property::HANDLE_VISUAL: + { + if( !sliderImpl.mHandleVisual.empty() ) + { + value = sliderImpl.GetHandleVisual(); + } + else if( !sliderImpl.mHandleMap.Empty() ) + { + value = sliderImpl.mHandleMap; + } + break; + } + + case Toolkit::Slider::Property::PROGRESS_VISUAL: + { + if( !sliderImpl.mProgressVisual.empty() ) + { + value = sliderImpl.GetProgressVisual(); + } + else if( !sliderImpl.mProgressMap.Empty() ) + { + value = sliderImpl.mProgressMap; + } + break; + } + + case Toolkit::Slider::Property::POPUP_VISUAL: + { + if( !sliderImpl.mPopupVisual.empty() ) + { + value = sliderImpl.GetPopupVisual(); + } + else if( !sliderImpl.mPopupMap.Empty() ) + { + value = sliderImpl.mPopupMap; + } + break; + } + + case Toolkit::Slider::Property::POPUP_ARROW_VISUAL: + { + if( !sliderImpl.mPopupArrowVisual.empty() ) + { + value = sliderImpl.GetPopupArrowVisual(); + } + else if( !sliderImpl.mPopupArrowMap.Empty() ) + { + value = sliderImpl.mPopupArrowMap; + } + break; + } + + case Toolkit::Slider::Property::DISABLED_COLOR: + { + value = sliderImpl.GetDisabledColor(); + break; + } + + case Toolkit::Slider::Property::VALUE_PRECISION: + { + value = sliderImpl.GetValuePrecision(); + break; + } + + case Toolkit::Slider::Property::SHOW_POPUP: + { + value = sliderImpl.GetShowPopup(); + break; + } + + case Toolkit::Slider::Property::SHOW_VALUE: + { + value = sliderImpl.GetShowValue(); + break; + } + + case Toolkit::Slider::Property::MARKS: + { + Property::Value value1( Property::ARRAY ); + Property::Array* markArray = value1.GetArray(); + + if( markArray ) + { + *markArray = sliderImpl.GetMarks(); + } + + value = value1; + break; + } + + case Toolkit::Slider::Property::SNAP_TO_MARKS: + { + value = sliderImpl.GetSnapToMarks(); + break; + } + + case Toolkit::Slider::Property::MARK_TOLERANCE: + { + value = sliderImpl.GetMarkTolerance(); + break; + } } } + + return value; +} + +double Slider::AccessibleImpl::GetMinimum() +{ + auto p = Toolkit::Slider::DownCast( self ); + return p.GetProperty( Toolkit::Slider::Property::LOWER_BOUND ).Get< float >(); +} + +double Slider::AccessibleImpl::GetCurrent() +{ + auto p = Toolkit::Slider::DownCast( self ); + return p.GetProperty( Toolkit::Slider::Property::VALUE ).Get< float >(); } +double Slider::AccessibleImpl::GetMaximum() +{ + auto p = Toolkit::Slider::DownCast( self ); + return p.GetProperty( Toolkit::Slider::Property::UPPER_BOUND ).Get< float >(); +} + +bool Slider::AccessibleImpl::SetCurrent( double current ) +{ + if (current < GetMinimum() || current > GetMaximum()) + return false; + + auto p = Toolkit::Slider::DownCast( self ); + auto &impl = Toolkit::GetImpl(p); + + const float prev = p.GetProperty(Toolkit::Slider::Property::VALUE); + float next = static_cast(current); + + if (fabsf(next - prev) < Math::MACHINE_EPSILON_0) + { + // do nothing + } + else if (p.GetProperty(Toolkit::Slider::Property::SNAP_TO_MARKS)) + { + auto marks = p.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 p = Toolkit::Slider::DownCast( self ); + + bool hasMarks = !p.GetProperty(Toolkit::Slider::Property::MARKS).Empty(); + float tolerance = p.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