/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * 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.
#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>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
using namespace Dali;
// Setup properties, signals and actions using the type-registry.
DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "lower-bound", FLOAT, LOWER_BOUND )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "upper-bound", FLOAT, UPPER_BOUND )
+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, "hit-region", VECTOR2, HIT_REGION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backing-region", VECTOR2, BACKING_REGION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handle-region", VECTOR2, HANDLE_REGION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "backing-image-name", STRING, BACKING_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handle-image-name", STRING, HANDLE_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progress-image-name", STRING, PROGRESS_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popup-image-name", STRING, POPUP_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popup-arrow-image-name", STRING, POPUP_ARROW_IMAGE_NAME )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disable-color", VECTOR4, DISABLE_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popup-text-color", VECTOR4, POPUP_TEXT_COLOR )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "value-precision", INTEGER, VALUE_PRECISION )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "show-popup", BOOLEAN, SHOW_POPUP )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "show-value", BOOLEAN, SHOW_VALUE )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "enabled", BOOLEAN, ENABLED )
+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, "snap-to-marks", BOOLEAN, SNAP_TO_MARKS )
-DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "mark-tolerance", FLOAT, MARK_TOLERANCE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snapToMarks", BOOLEAN, SNAP_TO_MARKS )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "markTolerance", FLOAT, MARK_TOLERANCE )
-DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "value-changed", SIGNAL_VALUE_CHANGED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "mark", SIGNAL_MARK )
DALI_TYPE_REGISTRATION_END()
-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)
-
const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec
const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
const float POPUP_TEXT_PADDING = 10.0f;
-const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.9.png";
-const char* SKINNED_HANDLE_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-handle.png";;
-const char* SKINNED_PROGRESS_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-progress.9.png";
-const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.9.png";
-const char* SKINNED_POPUP_ARROW_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup-arrow.png";
+const char* SKINNED_TRACK_VISUAL_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;
}
Slider::Slider()
-: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
+: Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
mState( NORMAL ),
- mDisableColor( 0.0f, 0.0f, 0.0f, 0.0f ),
- mPopupTextColor( 0.0f, 0.0f, 0.0f, 0.0f ),
+ mPopupVisual(""),
+ mPopupArrowVisual(""),
+ mTrackVisual(""),
+ mHandleVisual(""),
+ mProgressVisual(""),
+ mPopupMap(),
+ mTrackMap(),
+ mHandleMap(),
+ mPopupArrowMap(),
+ mDisabledColor( 0.0f, 0.0f, 0.0f, 0.0f ),
mHitRegion( 0.0f, 0.0f ),
- mBackingRegion( 0.0f, 0.0f ),
- mHandleRegionSize( 0.0f, 0.0f ),
+ mTrackRegion( 0.0f, 0.0f ),
+ mHandleSize( 0.0f, 0.0f ),
mLowerBound( 0.0f ),
mUpperBound( 0.0f ),
mValue( 0.0f ),
mShowValue( false ),
mSnapToMarks( false )
{
+ DevelControl::SetAccessibilityConstructor( Self(), []( Dali::Actor actor ) {
+ return std::unique_ptr< Dali::Accessibility::Accessible >(
+ new AccessibleImpl( actor, Dali::Accessibility::Role::SLIDER ) );
+ } );
}
Slider::~Slider()
Actor self = Self();
SetHitRegion( DEFAULT_HIT_REGION );
- SetBackingRegion( DEFAULT_BACKING_REGION );
- SetHandleRegion( DEFAULT_HANDLE_REGION );
-
- SetBackingImageName( SKINNED_BACKING_IMAGE_NAME );
- SetHandleImageName( SKINNED_HANDLE_IMAGE_NAME );
- SetProgressImageName( SKINNED_PROGRESS_IMAGE_NAME );
- SetPopupImageName( SKINNED_POPUP_IMAGE_NAME );
- SetPopupArrowImageName( SKINNED_POPUP_ARROW_IMAGE_NAME );
+ SetTrackRegion( DEFAULT_TRACK_REGION );
+ SetHandleSize( DEFAULT_HANDLE_SIZE );
- SetPopupTextColor( DEFAULT_POPUP_TEXT_COLOR );
+ 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 );
- SetDisableColor( DEFAULT_DISABLE_COLOR );
+ SetDisabledColor( DEFAULT_DISABLED_COLOR );
SetSnapToMarks( DEFAULT_SNAP_TO_MARKS );
SetMarkTolerance( MARK_SNAP_TOLERANCE );
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 ) );
+
+ // Connect to the touch signal
+ self.TouchedSignal().Connect( this, &Slider::OnTouch );
}
-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 )
{
}
}
- return true;
+ return false;
}
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 );
}
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 )
{
- mProgress.SetSize( x, GetBackingRegion().y );
+ 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 );
}
}
{
std::stringstream ss;
ss.precision( GetValuePrecision() );
- ss << std::fixed << clampledValue;
+ 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 )
{
- 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
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::SetBackingImageName( const std::string& imageName )
+void Slider::SetTrackVisual( const std::string& filename )
{
- if( mBacking && ( imageName.size() > 0 ) )
+ if( mHandle && ( filename.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mBacking.SetImage( image );
+ mTrack.SetImage( filename );
+ mTrackVisual = filename;
}
}
-std::string Slider::GetBackingImageName()
+void Slider::SetTrackVisual( Property::Map map )
{
- if( mBacking )
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
+ mTrackVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mTrack && ( filename.size() > 0 ) )
+ {
+ mTrack.SetImage( filename );
+ mTrackMap = map;
+ }
+ }
}
- return std::string( "" );
+ Property::Value* sizeValue = map.Find( "size" );
+ if( sizeValue )
+ {
+ 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()
{
- ImageActor progress = ImageActor::New();
- progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
- progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
- progress.SetZ( PROGRESS_Z );
+ return mTrackVisual;
+}
+
+Toolkit::ImageView Slider::CreateProgress()
+{
+ 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::SetProgressImageName( const std::string& imageName )
+void Slider::SetProgressVisual( const std::string& filename )
{
- if( mProgress && ( imageName.size() > 0 ) )
+ if( mProgress && ( filename.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mProgress.SetImage( image );
+ mProgress.SetImage( filename );
+ mProgressVisual = filename;
}
}
-std::string Slider::GetProgressImageName()
+void Slider::SetProgressVisual( Property::Map map )
{
- if( mProgress )
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
+ mProgressVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mProgress && ( filename.size() > 0 ) )
+ {
+ mProgress.SetImage( filename );
+ mProgressMap = map;
+ }
+ }
}
+}
+
+std::string Slider::GetProgressVisual()
+{
+ return mProgressVisual;
+}
- return std::string( "" );
+void Slider::SetPopupVisual( const std::string& filename )
+{
+ mPopupVisual = filename;
}
-void Slider::SetPopupImageName( const std::string& imageName )
+void Slider::SetPopupVisual( Property::Map map )
{
- mPopupImageName = imageName;
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
+ {
+ mPopupVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mPopup && ( filename.size() > 0 ) )
+ {
+ mPopup.SetImage( filename );
+ mPopupMap = map;
+ }
+ }
+ }
}
-std::string Slider::GetPopupImageName()
+std::string Slider::GetPopupVisual()
{
- return mPopupImageName;
+ return mPopupVisual;
}
-void Slider::CreatePopupImage( const std::string& imageName )
+void Slider::CreatePopupImage( const std::string& filename )
{
- if( mPopup && ( imageName.size() > 0 ) )
+ if( mPopup && ( filename.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mPopup.SetImage( image );
+ Property::Map map;
+ map[Toolkit::ImageVisual::Property::URL] = filename;
+ mPopup.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
}
}
-void Slider::SetPopupArrowImageName( const std::string& imageName )
+void Slider::SetPopupArrowVisual( const std::string& filename )
{
- mPopupArrowImageName = imageName;
+ mPopupArrowVisual = filename;
}
-std::string Slider::GetPopupArrowImageName()
+void Slider::SetPopupArrowVisual( Property::Map map )
{
- return mPopupArrowImageName;
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
+ {
+ mPopupArrowVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mPopupArrow && ( filename.size() > 0 ) )
+ {
+ mPopupArrow.SetImage( filename );
+ mPopupArrowMap = map;
+ }
+ }
+ }
}
-void Slider::CreatePopupArrowImage( const std::string& imageName )
+std::string Slider::GetPopupArrowVisual()
{
- if( mPopupArrow && ( imageName.size() > 0 ) )
+ return mPopupArrowVisual;
+}
+
+void Slider::CreatePopupArrowImage( const std::string& filename )
+{
+ if( mPopupArrow && ( filename.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mPopupArrow.SetImage( image );
+ Property::Map map;
+ map[Toolkit::ImageVisual::Property::URL] = filename;
+ mPopupArrow.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
}
}
{
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::TextLabel Slider::CreatePopupText()
{
Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
- textLabel.SetParentOrigin( ParentOrigin::CENTER );
- textLabel.SetAnchorPoint( AnchorPoint::CENTER );
+ 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( Toolkit::TextLabel::Property::TEXT_COLOR, DEFAULT_POPUP_TEXT_COLOR );
- textLabel.SetZ( VALUE_DISPLAY_TEXT_Z );
- textLabel.SetPadding( Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) );
+ textLabel.SetProperty( Actor::Property::PADDING, Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) );
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 );
mValueTextLabel = CreatePopupText();
return popup;
}
-void Slider::SetHandleImageName( const std::string& imageName )
+void Slider::SetHandleVisual( const std::string& filename )
{
- if( mHandle && ( imageName.size() > 0 ) )
+ if( mHandle && ( filename.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mHandle.SetImage( image );
+ mHandle.SetImage( filename );
+ mHandleVisual = filename;
}
}
-std::string Slider::GetHandleImageName()
+void Slider::SetHandleVisual( Property::Map map )
{
- if( mHandle )
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
+ mHandleVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mHandle && ( filename.size() > 0 ) )
+ {
+ mHandle.SetImage( filename );
+ mHandleMap = map;
+ }
+ }
}
- return std::string( "" );
+ Property::Value* sizeValue = map.Find( "size" );
+ if( sizeValue )
+ {
+ Vector2 size;
+ if( sizeValue->Get( size ) )
+ {
+ mHandleSize = size;
+ ResizeHandleSize( mHandleSize );
+
+ Vector2 hitRegion = GetHitRegion();
+ hitRegion.x += mHandleSize.x;
+ SetHitRegion( hitRegion );
+ }
+ }
+}
+
+std::string Slider::GetHandleVisual()
+{
+ return mHandleVisual;
}
-void Slider::ResizeHandleRegion( const Vector2& region )
+void Slider::ResizeHandleSize( const Vector2& size )
{
if( mHandle )
{
- mHandle.SetSize( region );
+ mHandle.SetProperty( Actor::Property::SIZE, size );
}
}
if( mHandle && !mHandleValueTextLabel )
{
mHandleValueTextLabel = Toolkit::TextLabel::New();
- mHandleValueTextLabel.SetParentOrigin( ParentOrigin::CENTER );
- mHandleValueTextLabel.SetAnchorPoint( AnchorPoint::CENTER );
+ 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.SetDrawMode( DrawMode::OVERLAY );
mHandle.Add( mHandleValueTextLabel );
}
}
UnparentAndReset(mHandleValueTextLabel);
}
-void Slider::SetPopupTextColor( const Vector4& color )
-{
- mPopupTextColor = color;
-}
-
Actor Slider::CreateValueDisplay()
{
Actor popup = Actor::New();
- popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
- popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+ popup.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER );
+ popup.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER );
mPopupArrow = CreatePopupArrow();
popup.Add( mPopupArrow );
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;
return mSlidingFinishedSignal;
}
-Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
+Toolkit::Slider::MarkReachedSignalType& Slider::MarkReachedSignal()
{
- return mMarkSignal;
+ return mMarkReachedSignal;
}
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:
mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan );
self.Add( mHitArea );
- // Background
- mBacking = CreateBacking();
- self.Add( mBacking );
+ // Track
+ mTrack = CreateTrack();
+ self.Add( mTrack );
// Progress bar
mProgress = CreateProgress();
- mBacking.Add( mProgress );
+ mTrack.Add( mProgress );
// Handle
mHandle = CreateHandle();
- mBacking.Add( mHandle );
+ mProgress.Add( mHandle );
}
void Slider::SetHitRegion( const Vector2& size )
if( mHitArea )
{
- mHitArea.SetSize( mHitRegion );
+ mHitArea.SetProperty( Actor::Property::SIZE, mHitRegion );
}
}
if( !mValueDisplay )
{
mValueDisplay = CreateValueDisplay();
- mValueDisplay.SetVisible( false );
+ mValueDisplay.SetProperty( Actor::Property::VISIBLE, false );
mHandle.Add( mValueDisplay );
- CreatePopupImage( GetPopupImageName() );
- CreatePopupArrowImage( GetPopupArrowImageName() );
+ CreatePopupImage( GetPopupVisual() );
+ CreatePopupArrowImage( GetPopupArrowVisual() );
mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
const float MARK_TOLERANCE = GetMarkTolerance();
float mark;
- for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it )
+ for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i)
{
- const Property::Value& propertyValue = *it;
+ const Property::Value& propertyValue = mMarks[i];
propertyValue.Get( mark );
mark = MapValuePercentage( mark );
float closestDist = std::numeric_limits<float>::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 );
// Binary search
int head = 0,
- tail = mMarks.size() - 1;
+ tail = mMarks.Size() - 1;
int current;
float mark;
{
if( mValueDisplay )
{
- mValueDisplay.SetVisible( false );
+ mValueDisplay.SetProperty( Actor::Property::VISIBLE, false );
}
return false;
return mValue;
}
-void Slider::SetBackingRegion( const Vector2& region )
+void Slider::SetTrackRegion( const Vector2& region )
{
- mBackingRegion = region;
+ mTrackRegion = region;
- if( mBacking )
+ if( mTrack )
{
- mBacking.SetSize( mBackingRegion );
+ mTrack.SetProperty( Actor::Property::SIZE, mTrackRegion );
}
- ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
+ ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
- mDomain = CalcDomain( mBackingRegion );
+ mDomain = CalcDomain( mTrackRegion );
DisplayValue( GetValue(), false ); // Set the progress bar to correct width
}
-const Vector2& Slider::GetBackingRegion() const
+const Vector2& Slider::GetTrackRegion() const
{
- return mBackingRegion;
+ return mTrackRegion;
}
-void Slider::SetHandleRegion( const Vector2& region )
+void Slider::SetHandleSize( const Vector2& size )
{
- mHandleRegionSize = region;
+ mHandleSize = size;
- ResizeHandleRegion( mHandleRegionSize );
+ ResizeHandleSize( mHandleSize );
Vector2 hitRegion = GetHitRegion();
- hitRegion.x += mHandleRegionSize.x;
+ hitRegion.x += mHandleSize.x;
SetHitRegion( hitRegion );
}
-const Vector2& Slider::GetHandleRegion() const
+const Vector2& Slider::GetHandleSize() const
{
- return mHandleRegionSize;
+ return mHandleSize;
}
-void Slider::SetDisableColor( const Vector4& color )
+void Slider::SetDisabledColor( const Vector4& color )
{
- mDisableColor = color;
+ mDisabledColor = color;
UpdateSkin();
}
-Vector4 Slider::GetDisableColor() const
-{
- return mDisableColor;
-}
-
-Vector4 Slider::GetPopupTextColor() const
+Vector4 Slider::GetDisabledColor() const
{
- return mPopupTextColor;
+ return mDisabledColor;
}
void Slider::SetValuePrecision( int precision )
}
else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
{
- slider.MarkSignal().Connect( tracker, functor );
+ slider.MarkReachedSignal().Connect( tracker, functor );
}
else
{
if( mValueDisplay )
{
- mValueDisplay.SetVisible( true );
+ mValueDisplay.SetProperty( Actor::Property::VISIBLE, true );
mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
}
break;
}
- case Toolkit::Slider::Property::HIT_REGION:
- {
- sliderImpl.SetHitRegion( value.Get< Vector2 >() );
- break;
- }
-
- case Toolkit::Slider::Property::BACKING_REGION:
+ case Toolkit::Slider::Property::TRACK_VISUAL:
{
- sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
- break;
- }
-
- case Toolkit::Slider::Property::HANDLE_REGION:
- {
- sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetTrackVisual( map );
+ }
break;
}
- case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
+ case Toolkit::Slider::Property::HANDLE_VISUAL:
{
- sliderImpl.SetBackingImageName( value.Get< std::string >() );
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetHandleVisual( map );
+ }
break;
}
- case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
+ case Toolkit::Slider::Property::PROGRESS_VISUAL:
{
- sliderImpl.SetHandleImageName( value.Get< std::string >() );
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetProgressVisual( map );
+ }
break;
}
- case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
+ case Toolkit::Slider::Property::POPUP_VISUAL:
{
- sliderImpl.SetProgressImageName( value.Get< std::string >() );
- break;
- }
+ std::string imageUrl;
+ if( value.Get( imageUrl ) )
+ {
+ sliderImpl.SetPopupVisual( imageUrl );
+ }
- case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
- {
- sliderImpl.SetPopupImageName( value.Get< std::string >() );
- break;
- }
+ // If it is not a string, then get a Property::Map from the property if possible.
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetPopupVisual( map );
+ }
- case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
- {
- sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
break;
}
- case Toolkit::Slider::Property::DISABLE_COLOR:
+ case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
{
- sliderImpl.SetDisableColor( value.Get< Vector4 >() );
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetPopupArrowVisual( map );
+ }
break;
}
- case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
+ case Toolkit::Slider::Property::DISABLED_COLOR:
{
- sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
+ sliderImpl.SetDisabledColor( value.Get< Vector4 >() );
break;
}
break;
}
- case Toolkit::Slider::Property::ENABLED:
- {
- sliderImpl.SetEnabled( value.Get< bool >() );
- break;
- }
-
case Toolkit::Slider::Property::MARKS:
{
sliderImpl.SetMarks( value.Get< Property::Array >() );
break;
}
- case Toolkit::Slider::Property::HIT_REGION:
+ case Toolkit::Slider::Property::TRACK_VISUAL:
{
- value = sliderImpl.GetHitRegion();
- break;
- }
-
- case Toolkit::Slider::Property::BACKING_REGION:
- {
- value = sliderImpl.GetBackingRegion();
- break;
- }
-
- case Toolkit::Slider::Property::HANDLE_REGION:
- {
- value = sliderImpl.GetHandleRegion();
- break;
- }
-
- case Toolkit::Slider::Property::BACKING_IMAGE_NAME:
- {
- value = sliderImpl.GetBackingImageName();
- break;
- }
-
- case Toolkit::Slider::Property::HANDLE_IMAGE_NAME:
- {
- value = sliderImpl.GetHandleImageName();
+ if( !sliderImpl.mTrackVisual.empty() )
+ {
+ value = sliderImpl.GetTrackVisual();
+ }
+ else if( !sliderImpl.mTrackMap.Empty() )
+ {
+ value = sliderImpl.mTrackMap;
+ }
break;
}
- case Toolkit::Slider::Property::PROGRESS_IMAGE_NAME:
+ case Toolkit::Slider::Property::HANDLE_VISUAL:
{
- value = sliderImpl.GetProgressImageName();
+ if( !sliderImpl.mHandleVisual.empty() )
+ {
+ value = sliderImpl.GetHandleVisual();
+ }
+ else if( !sliderImpl.mHandleMap.Empty() )
+ {
+ value = sliderImpl.mHandleMap;
+ }
break;
}
- case Toolkit::Slider::Property::POPUP_IMAGE_NAME:
+ case Toolkit::Slider::Property::PROGRESS_VISUAL:
{
- value = sliderImpl.GetPopupImageName();
+ if( !sliderImpl.mProgressVisual.empty() )
+ {
+ value = sliderImpl.GetProgressVisual();
+ }
+ else if( !sliderImpl.mProgressMap.Empty() )
+ {
+ value = sliderImpl.mProgressMap;
+ }
break;
}
- case Toolkit::Slider::Property::POPUP_ARROW_IMAGE_NAME:
+ case Toolkit::Slider::Property::POPUP_VISUAL:
{
- value = sliderImpl.GetPopupArrowImageName();
+ if( !sliderImpl.mPopupVisual.empty() )
+ {
+ value = sliderImpl.GetPopupVisual();
+ }
+ else if( !sliderImpl.mPopupMap.Empty() )
+ {
+ value = sliderImpl.mPopupMap;
+ }
break;
}
- case Toolkit::Slider::Property::DISABLE_COLOR:
+ case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
{
- value = sliderImpl.GetDisableColor();
+ if( !sliderImpl.mPopupArrowVisual.empty() )
+ {
+ value = sliderImpl.GetPopupArrowVisual();
+ }
+ else if( !sliderImpl.mPopupArrowMap.Empty() )
+ {
+ value = sliderImpl.mPopupArrowMap;
+ }
break;
}
- case Toolkit::Slider::Property::POPUP_TEXT_COLOR:
+ case Toolkit::Slider::Property::DISABLED_COLOR:
{
- value = sliderImpl.GetPopupTextColor();
+ value = sliderImpl.GetDisabledColor();
break;
}
break;
}
- case Toolkit::Slider::Property::ENABLED:
- {
- value = sliderImpl.IsEnabled();
- break;
- }
-
case Toolkit::Slider::Property::MARKS:
{
- // TODO: Need to be able to return a PropertyArray
- // value = sliderImpl.GetMarks();
+ Property::Value value1( Property::ARRAY );
+ Property::Array* markArray = value1.GetArray();
+
+ if( markArray )
+ {
+ *markArray = sliderImpl.GetMarks();
+ }
+
+ value = value1;
break;
}
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 );
+ p.SetProperty( Toolkit::Slider::Property::VALUE, static_cast< float >( current ) );
+ return true;
+}
+
+double Slider::AccessibleImpl::GetMinimumIncrement()
+{
+ auto p = Toolkit::Slider::DownCast( self );
+ return p.GetProperty( Toolkit::Slider::Property::MARK_TOLERANCE ).Get< float >();
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff