/*
- * 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.
#include <dali-toolkit/internal/controls/slider/slider-impl.h>
// EXTERNAL INCLUDES
-#include <cstring> // for strcmp
-#include <sstream>
-#include <limits>
#include <dali/public-api/events/touch-event.h>
-#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
-#include <dali/public-api/images/resource-image.h>
+#include <dali/public-api/object/type-registry.h>
+#include <cstring> // for strcmp
+#include <limits>
+#include <sstream>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
+#include <dali-toolkit/internal/controls/control/control-data-impl.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
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, "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_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_TRACK_VISUAL = DALI_IMAGE_DIR "slider-skin.9.png";
-const char* SKINNED_HANDLE_VISUAL = DALI_IMAGE_DIR "slider-skin-handle.png";
-const char* SKINNED_PROGRESS_VISUAL = DALI_IMAGE_DIR "slider-skin-progress.9.png";
-const char* SKINNED_POPUP_VISUAL = DALI_IMAGE_DIR "slider-popup.9.png";
-const char* SKINNED_POPUP_ARROW_VISUAL = DALI_IMAGE_DIR "slider-popup-arrow.png";
+const 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_TRACK_REGION( DEFAULT_WIDTH, DEFAULT_HEIGHT );
-const Vector2 DEFAULT_HANDLE_SIZE( 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_DISABLED_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
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...
}
Slider::Slider()
-: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
- mState( NORMAL ),
+: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
+ mState(NORMAL),
mPopupVisual(""),
mPopupArrowVisual(""),
mTrackVisual(""),
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 )
+ 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)
{
}
// Properties
Actor self = Self();
- SetHitRegion( DEFAULT_HIT_REGION );
- SetTrackRegion( DEFAULT_TRACK_REGION );
- SetHandleSize( DEFAULT_HANDLE_SIZE );
+ SetHitRegion(DEFAULT_HIT_REGION);
+ SetTrackRegion(DEFAULT_TRACK_REGION);
+ SetHandleSize(DEFAULT_HANDLE_SIZE);
- SetTrackVisual( SKINNED_TRACK_VISUAL );
- SetHandleVisual( SKINNED_HANDLE_VISUAL );
- SetProgressVisual( SKINNED_PROGRESS_VISUAL );
- SetPopupVisual( SKINNED_POPUP_VISUAL );
- SetPopupArrowVisual( SKINNED_POPUP_ARROW_VISUAL );
+ 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 );
- SetDisabledColor( DEFAULT_DISABLED_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<Dali::Accessibility::Accessible>(
+ new AccessibleImpl(actor, Dali::Accessibility::Role::SLIDER));
+ });
}
-void Slider::OnSizeSet( const Vector3& size )
+void Slider::OnRelayout(const Vector2& size, RelayoutContainer& container)
{
- // Factor in handle overshoot into size of track
- SetHitRegion( Vector2( size.x, GetHitRegion().y ) );
- SetTrackRegion( Vector2( size.x - GetHandleSize().x, GetTrackRegion().y ) );
+ SetHitRegion(Vector2(size.x, GetHitRegion().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 )
+ 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;
}
}
-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, GetTrackRegion().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))
{
- mMarkReachedSignal.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<std::string>(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;
}
return mMarks;
}
-void Slider::SetSnapToMarks( bool snap )
+void Slider::SetSnapToMarks(bool snap)
{
mSnapToMarks = snap;
}
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::CreateTrack()
{
Toolkit::ImageView track = Toolkit::ImageView::New();
- track.SetParentOrigin( ParentOrigin::CENTER );
- track.SetAnchorPoint( AnchorPoint::CENTER );
-
+ 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::SetTrackVisual( const std::string& filename )
+void Slider::SetTrackVisual(const std::string& filename)
{
- if( mHandle && ( filename.size() > 0 ) )
+ if(mHandle && (filename.size() > 0))
{
- mTrack.SetImage( filename );
+ mTrack.SetImage(filename);
mTrackVisual = filename;
}
}
-void Slider::SetTrackVisual( Property::Map map )
+void Slider::SetTrackVisual(Property::Map map)
{
- Property::Value* imageValue = map.Find( "url" );
- if( imageValue )
+ Property::Value* imageValue = map.Find("url");
+ if(imageValue)
{
mTrackVisual.clear();
std::string filename;
- if( imageValue->Get( filename ) )
+ if(imageValue->Get(filename))
{
- if( mTrack && ( filename.size() > 0 ) )
+ if(mTrack && (filename.size() > 0))
{
- mTrack.SetImage( filename );
+ mTrack.SetImage(filename);
mTrackMap = map;
}
}
}
- Property::Value* sizeValue = map.Find( "size" );
- if( sizeValue )
+ Property::Value* sizeValue = map.Find("size");
+ if(sizeValue)
{
Vector2 size;
- if( sizeValue->Get( size ) )
+ if(sizeValue->Get(size))
{
mTrackRegion = size;
- if( mTrack )
+ if(mTrack)
{
- mTrack.SetSize( mTrackRegion );
+ mTrack.SetProperty(Actor::Property::SIZE, mTrackRegion);
}
- ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
+ ResizeProgressRegion(Vector2(0.0f, mTrackRegion.y));
- mDomain = CalcDomain( mTrackRegion );
+ mDomain = CalcDomain(mTrackRegion);
- // Set the progress bar to correct width
- DisplayValue( GetValue(), false );
+ // Set the progress bar to correct width
+ DisplayValue(GetValue(), false);
}
}
}
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::SetProgressVisual( const std::string& filename )
+void Slider::SetProgressVisual(const std::string& filename)
{
- if( mProgress && ( filename.size() > 0 ) )
+ if(mProgress && (filename.size() > 0))
{
- mProgress.SetImage( filename );
+ mProgress.SetImage(filename);
mProgressVisual = filename;
}
}
-void Slider::SetProgressVisual( Property::Map map )
+void Slider::SetProgressVisual(Property::Map map)
{
- Property::Value* imageValue = map.Find( "url" );
- if( imageValue )
+ Property::Value* imageValue = map.Find("url");
+ if(imageValue)
{
mProgressVisual.clear();
std::string filename;
- if( imageValue->Get( filename ) )
+ if(imageValue->Get(filename))
{
- if( mProgress && ( filename.size() > 0 ) )
+ if(mProgress && (filename.size() > 0))
{
- mProgress.SetImage( filename );
+ mProgress.SetImage(filename);
mProgressMap = map;
}
}
return mProgressVisual;
}
-void Slider::SetPopupVisual( const std::string& filename )
+void Slider::SetPopupVisual(const std::string& filename)
{
mPopupVisual = filename;
}
-void Slider::SetPopupVisual( Property::Map map )
+void Slider::SetPopupVisual(Property::Map map)
{
- Property::Value* imageValue = map.Find( "url" );
- if( imageValue )
+ Property::Value* imageValue = map.Find("url");
+ if(imageValue)
{
mPopupVisual.clear();
std::string filename;
- if( imageValue->Get( filename ) )
+ if(imageValue->Get(filename))
{
- if( mPopup && ( filename.size() > 0 ) )
+ if(mPopup && (filename.size() > 0))
{
- mPopup.SetImage( filename );
+ mPopup.SetImage(filename);
mPopupMap = map;
}
}
return mPopupVisual;
}
-void Slider::CreatePopupImage( const std::string& filename )
+void Slider::CreatePopupImage(const std::string& filename)
{
- if( mPopup && ( filename.size() > 0 ) )
+ if(mPopup && (filename.size() > 0))
{
- Image image = ResourceImage::New( filename );
- mPopup.SetImage( image );
+ Property::Map map;
+ map[Toolkit::ImageVisual::Property::URL] = filename;
+ mPopup.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
}
}
-void Slider::SetPopupArrowVisual( const std::string& filename )
+void Slider::SetPopupArrowVisual(const std::string& filename)
{
mPopupArrowVisual = filename;
}
-void Slider::SetPopupArrowVisual( Property::Map map )
+void Slider::SetPopupArrowVisual(Property::Map map)
{
- Property::Value* imageValue = map.Find( "url" );
- if( imageValue )
+ Property::Value* imageValue = map.Find("url");
+ if(imageValue)
{
mPopupArrowVisual.clear();
std::string filename;
- if( imageValue->Get( filename ) )
+ if(imageValue->Get(filename))
{
- if( mPopupArrow && ( filename.size() > 0 ) )
+ if(mPopupArrow && (filename.size() > 0))
{
- mPopupArrow.SetImage( filename );
+ mPopupArrow.SetImage(filename);
mPopupArrowMap = map;
}
}
return mPopupArrowVisual;
}
-void Slider::CreatePopupArrowImage( const std::string& filename )
+void Slider::CreatePopupArrowImage(const std::string& filename)
{
- if( mPopupArrow && ( filename.size() > 0 ) )
+ if(mPopupArrow && (filename.size() > 0))
{
- Image image = ResourceImage::New( filename );
- mPopupArrow.SetImage( image );
+ 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;
}
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;
}
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.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::SetHandleVisual( const std::string& filename )
+void Slider::SetHandleVisual(const std::string& filename)
{
- if( mHandle && ( filename.size() > 0 ) )
+ if(mHandle && (filename.size() > 0))
{
- mHandle.SetImage( filename );
+ mHandle.SetImage(filename);
mHandleVisual = filename;
}
}
-void Slider::SetHandleVisual( Property::Map map )
+void Slider::SetHandleVisual(Property::Map map)
{
- Property::Value* imageValue = map.Find( "url" );
- if( imageValue )
+ Property::Value* imageValue = map.Find("url");
+ if(imageValue)
{
mHandleVisual.clear();
std::string filename;
- if( imageValue->Get( filename ) )
+ if(imageValue->Get(filename))
{
- if( mHandle && ( filename.size() > 0 ) )
+ if(mHandle && (filename.size() > 0))
{
- mHandle.SetImage( filename );
+ mHandle.SetImage(filename);
mHandleMap = map;
}
}
}
- Property::Value* sizeValue = map.Find( "size" );
- if( sizeValue )
+ Property::Value* sizeValue = map.Find("size");
+ if(sizeValue)
{
Vector2 size;
- if( sizeValue->Get( size ) )
+ if(sizeValue->Get(size))
{
mHandleSize = size;
- ResizeHandleSize( mHandleSize );
+ ResizeHandleSize(mHandleSize);
Vector2 hitRegion = GetHitRegion();
hitRegion.x += mHandleSize.x;
- SetHitRegion( hitRegion );
+ SetHitRegion(hitRegion);
}
}
}
return mHandleVisual;
}
-void Slider::ResizeHandleSize( const Vector2& size )
+void Slider::ResizeHandleSize(const Vector2& size)
{
- if( mHandle )
+ if(mHandle)
{
- mHandle.SetSize( size );
+ 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);
}
}
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;
}
void Slider::UpdateSkin()
{
- switch( mState )
+ switch(mState)
{
case NORMAL:
{
- mTrack.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 disabledColor = GetDisabledColor();
- mTrack.SetColor( disabledColor );
- mHandle.SetColor( disabledColor );
- mProgress.SetColor( disabledColor );
+ mTrack.SetProperty(Actor::Property::COLOR, disabledColor);
+ mHandle.SetProperty(Actor::Property::COLOR, disabledColor);
+ mProgress.SetProperty(Actor::Property::COLOR, disabledColor);
break;
}
case PRESSED:
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);
// Track
mTrack = CreateTrack();
- self.Add( mTrack );
+ self.Add(mTrack);
// Progress bar
mProgress = CreateProgress();
- mTrack.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);
}
}
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( GetPopupVisual() );
- CreatePopupArrowImage( GetPopupArrowVisual() );
+ 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();
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<float>::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;
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;
}
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
return mLowerBound;
}
-void Slider::SetUpperBound( float bound )
+void Slider::SetUpperBound(float bound)
{
mUpperBound = bound;
- DisplayValue( GetValue(), false );
+ DisplayValue(GetValue(), false);
}
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
return mValue;
}
-void Slider::SetTrackRegion( const Vector2& region )
+void Slider::SetTrackRegion(const Vector2& region)
{
mTrackRegion = region;
- if( mTrack )
+ if(mTrack)
{
- mTrack.SetSize( mTrackRegion );
+ mTrack.SetProperty(Actor::Property::SIZE, mTrackRegion);
}
- ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
+ ResizeProgressRegion(Vector2(0.0f, mTrackRegion.y));
- mDomain = CalcDomain( mTrackRegion );
+ 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::GetTrackRegion() const
return mTrackRegion;
}
-void Slider::SetHandleSize( const Vector2& size )
+void Slider::SetHandleSize(const Vector2& size)
{
mHandleSize = size;
- ResizeHandleSize( mHandleSize );
+ ResizeHandleSize(mHandleSize);
Vector2 hitRegion = GetHitRegion();
hitRegion.x += mHandleSize.x;
- SetHitRegion( hitRegion );
+ SetHitRegion(hitRegion);
}
const Vector2& Slider::GetHandleSize() const
return mHandleSize;
}
-void Slider::SetDisabledColor( const Vector4& color )
+void Slider::SetDisabledColor(const Vector4& color)
{
mDisabledColor = color;
return mDisabledColor;
}
-void Slider::SetValuePrecision( int precision )
+void Slider::SetValuePrecision(int precision)
{
mValuePrecision = precision;
}
return mValuePrecision;
}
-void Slider::SetShowPopup( bool showPopup )
+void Slider::SetShowPopup(bool showPopup)
{
mShowPopup = showPopup;
// Value display
- if( mShowPopup )
+ if(mShowPopup)
{
AddPopup();
}
return mShowPopup;
}
-void Slider::SetShowValue( bool showValue )
+void Slider::SetShowValue(bool showValue)
{
mShowValue = showValue;
- if( mShowValue )
+ if(mShowValue)
{
CreateHandleValueDisplay();
}
return mShowValue;
}
-void Slider::SetEnabled( bool enabled )
+void Slider::SetEnabled(bool enabled)
{
- if( enabled )
+ if(enabled)
{
mState = NORMAL;
}
return mState != DISABLED;
}
-void Slider::SetMarkTolerance( float tolerance )
+void Slider::SetMarkTolerance(float tolerance)
{
mMarkTolerance = tolerance;
}
}
// 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.MarkReachedSignal().Connect( tracker, functor );
+ slider.MarkReachedSignal().Connect(tracker, functor);
}
else
{
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<float>());
break;
}
case Toolkit::Slider::Property::UPPER_BOUND:
{
- sliderImpl.SetUpperBound( value.Get< float >() );
+ sliderImpl.SetUpperBound(value.Get<float>());
break;
}
case Toolkit::Slider::Property::VALUE:
{
- sliderImpl.SetValue( value.Get< float >() );
+ sliderImpl.SetValue(value.Get<float>());
break;
}
case Toolkit::Slider::Property::TRACK_VISUAL:
{
Property::Map map;
- if( value.Get( map ) )
+ if(value.Get(map))
{
- sliderImpl.SetTrackVisual( map );
+ sliderImpl.SetTrackVisual(map);
}
break;
}
case Toolkit::Slider::Property::HANDLE_VISUAL:
{
Property::Map map;
- if( value.Get( map ) )
+ if(value.Get(map))
{
- sliderImpl.SetHandleVisual( map );
+ sliderImpl.SetHandleVisual(map);
}
break;
}
case Toolkit::Slider::Property::PROGRESS_VISUAL:
{
Property::Map map;
- if( value.Get( map ) )
+ if(value.Get(map))
{
- sliderImpl.SetProgressVisual( map );
+ sliderImpl.SetProgressVisual(map);
}
break;
}
case Toolkit::Slider::Property::POPUP_VISUAL:
{
std::string imageUrl;
- if( value.Get( imageUrl ) )
+ if(value.Get(imageUrl))
{
- sliderImpl.SetPopupVisual( 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 ) )
+ if(value.Get(map))
{
- sliderImpl.SetPopupVisual( map );
+ sliderImpl.SetPopupVisual(map);
}
break;
case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
{
Property::Map map;
- if( value.Get( map ) )
+ if(value.Get(map))
{
- sliderImpl.SetPopupArrowVisual( map );
+ sliderImpl.SetPopupArrowVisual(map);
}
break;
}
case Toolkit::Slider::Property::DISABLED_COLOR:
{
- sliderImpl.SetDisabledColor( value.Get< Vector4 >() );
+ sliderImpl.SetDisabledColor(value.Get<Vector4>());
break;
}
case Toolkit::Slider::Property::VALUE_PRECISION:
{
- sliderImpl.SetValuePrecision( value.Get< int >() );
+ sliderImpl.SetValuePrecision(value.Get<int>());
break;
}
case Toolkit::Slider::Property::SHOW_POPUP:
{
- sliderImpl.SetShowPopup( value.Get< bool >() );
+ sliderImpl.SetShowPopup(value.Get<bool>());
break;
}
case Toolkit::Slider::Property::SHOW_VALUE:
{
- sliderImpl.SetShowValue( value.Get< bool >() );
+ sliderImpl.SetShowValue(value.Get<bool>());
break;
}
case Toolkit::Slider::Property::MARKS:
{
- sliderImpl.SetMarks( value.Get< Property::Array >() );
+ sliderImpl.SetMarks(value.Get<Property::Array>());
break;
}
case Toolkit::Slider::Property::SNAP_TO_MARKS:
{
- sliderImpl.SetSnapToMarks( value.Get< bool >() );
+ sliderImpl.SetSnapToMarks(value.Get<bool>());
break;
}
case Toolkit::Slider::Property::MARK_TOLERANCE:
{
- sliderImpl.SetMarkTolerance( value.Get< float >() );
+ sliderImpl.SetMarkTolerance(value.Get<float>());
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:
{
case Toolkit::Slider::Property::TRACK_VISUAL:
{
- if( !sliderImpl.mTrackVisual.empty() )
+ if(!sliderImpl.mTrackVisual.empty())
{
value = sliderImpl.GetTrackVisual();
}
- else if( !sliderImpl.mTrackMap.Empty() )
+ else if(!sliderImpl.mTrackMap.Empty())
{
value = sliderImpl.mTrackMap;
}
case Toolkit::Slider::Property::HANDLE_VISUAL:
{
- if( !sliderImpl.mHandleVisual.empty() )
+ if(!sliderImpl.mHandleVisual.empty())
{
value = sliderImpl.GetHandleVisual();
}
- else if( !sliderImpl.mHandleMap.Empty() )
+ else if(!sliderImpl.mHandleMap.Empty())
{
value = sliderImpl.mHandleMap;
}
case Toolkit::Slider::Property::PROGRESS_VISUAL:
{
- if( !sliderImpl.mProgressVisual.empty() )
+ if(!sliderImpl.mProgressVisual.empty())
{
value = sliderImpl.GetProgressVisual();
}
- else if( !sliderImpl.mProgressMap.Empty() )
+ else if(!sliderImpl.mProgressMap.Empty())
{
value = sliderImpl.mProgressMap;
}
case Toolkit::Slider::Property::POPUP_VISUAL:
{
- if( !sliderImpl.mPopupVisual.empty() )
+ if(!sliderImpl.mPopupVisual.empty())
{
value = sliderImpl.GetPopupVisual();
}
- else if( !sliderImpl.mPopupMap.Empty() )
+ else if(!sliderImpl.mPopupMap.Empty())
{
value = sliderImpl.mPopupMap;
}
case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
{
- if( !sliderImpl.mPopupArrowVisual.empty() )
+ if(!sliderImpl.mPopupArrowVisual.empty())
{
value = sliderImpl.GetPopupArrowVisual();
}
- else if( !sliderImpl.mPopupArrowMap.Empty() )
+ else if(!sliderImpl.mPopupArrowMap.Empty())
{
value = sliderImpl.mPopupArrowMap;
}
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;
}
return value;
}
+double Slider::AccessibleImpl::GetMinimum()
+{
+ auto self = Toolkit::Slider::DownCast(Self());
+ return self.GetProperty(Toolkit::Slider::Property::LOWER_BOUND).Get<float>();
+}
+
+double Slider::AccessibleImpl::GetCurrent()
+{
+ auto self = Toolkit::Slider::DownCast(Self());
+ return self.GetProperty(Toolkit::Slider::Property::VALUE).Get<float>();
+}
+
+double Slider::AccessibleImpl::GetMaximum()
+{
+ auto self = Toolkit::Slider::DownCast(Self());
+ return self.GetProperty(Toolkit::Slider::Property::UPPER_BOUND).Get<float>();
+}
+
+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<float>(Toolkit::Slider::Property::VALUE);
+ float next = static_cast<float>(current);
+
+ if(fabsf(next - prev) < Math::MACHINE_EPSILON_0)
+ {
+ // do nothing
+ }
+ else if(self.GetProperty<bool>(Toolkit::Slider::Property::SNAP_TO_MARKS))
+ {
+ auto marks = self.GetProperty<Property::Array>(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<int>(marks.Count()))
+ {
+ return false;
+ }
+
+ next = marks[nextIdx].Get<float>();
+ }
+ 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<Property::Array>(Toolkit::Slider::Property::MARKS).Empty();
+ float tolerance = self.GetProperty<float>(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
projects / platform / core / uifw / dali-toolkit.git / blobdiff