namespace Toolkit
{
+// Properties
+const Property::Index Slider::LOWER_BOUND_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 1;
+const Property::Index Slider::UPPER_BOUND_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 2;
+
+const Property::Index Slider::VALUE_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 3;
+const Property::Index Slider::HIT_REGION_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 4;
+const Property::Index Slider::BACKING_REGION_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 5;
+const Property::Index Slider::HANDLE_REGION_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 6;
+
+const Property::Index Slider::BACKING_IMAGE_NAME_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 7;
+const Property::Index Slider::HANDLE_IMAGE_NAME_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 8;
+const Property::Index Slider::PROGRESS_IMAGE_NAME_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 9;
+const Property::Index Slider::POPUP_IMAGE_NAME_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 10;
+const Property::Index Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 11;
+
+const Property::Index Slider::DISABLE_COLOR_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 12;
+const Property::Index Slider::POPUP_TEXT_COLOR_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 13;
+
+const Property::Index Slider::VALUE_PRECISION_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 14;
+
+const Property::Index Slider::SHOW_POPUP_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 15;
+const Property::Index Slider::SHOW_VALUE_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 16;
+
+const Property::Index Slider::ENABLED_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 17;
+
+const Property::Index Slider::MARKS_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 18;
+const Property::Index Slider::SNAP_TO_MARKS_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 19;
+const Property::Index Slider::MARK_TOLERANCE_PROPERTY = ControlImpl::CONTROL_PROPERTY_END_INDEX + 20;
+
namespace Internal
{
const float DEFAULT_HIT_HEIGHT = 72.0f;
const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
-const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.png";
+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.png";
-const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.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 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 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 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()
{
SignalConnectorType signalConnector1( typeRegistration, Toolkit::Slider::SIGNAL_VALUE_CHANGED, &Toolkit::Internal::Slider::DoConnectSignal );
SignalConnectorType signalConnector2( typeRegistration, Toolkit::Slider::SIGNAL_MARK, &Toolkit::Internal::Slider::DoConnectSignal );
+PropertyRegistration property1( typeRegistration, "lower-bound", Toolkit::Slider::LOWER_BOUND_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property2( typeRegistration, "upper-bound", Toolkit::Slider::UPPER_BOUND_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property3( typeRegistration, "value", Toolkit::Slider::VALUE_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty );
+
+PropertyRegistration property4( typeRegistration, "hit-region", Toolkit::Slider::HIT_REGION_PROPERTY, Property::VECTOR2, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property5( typeRegistration, "backing-region", Toolkit::Slider::BACKING_REGION_PROPERTY, Property::VECTOR2, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property6( typeRegistration, "handle-region", Toolkit::Slider::HANDLE_REGION_PROPERTY, Property::VECTOR2, &Slider::SetProperty, &Slider::GetProperty );
+
+PropertyRegistration property7( typeRegistration, "backing-image-name", Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property8( typeRegistration, "handle-image-name", Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property9( typeRegistration, "progress-image-name", Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property10( typeRegistration, "popup-image-name", Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property11( typeRegistration, "popup-arrow-image-name", Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY, Property::STRING, &Slider::SetProperty, &Slider::GetProperty );
+
+PropertyRegistration property12( typeRegistration, "disable-color", Toolkit::Slider::DISABLE_COLOR_PROPERTY, Property::VECTOR4, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property13( typeRegistration, "popup-text-color", Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY, Property::VECTOR4, &Slider::SetProperty, &Slider::GetProperty );
+
+PropertyRegistration property14( typeRegistration, "value-precision", Toolkit::Slider::VALUE_PRECISION_PROPERTY, Property::INTEGER, &Slider::SetProperty, &Slider::GetProperty );
+
+PropertyRegistration property15( typeRegistration, "show-popup", Toolkit::Slider::SHOW_POPUP_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property16( typeRegistration, "show-value", Toolkit::Slider::SHOW_VALUE_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty );
+
+PropertyRegistration property17( typeRegistration, "enabled", Toolkit::Slider::ENABLED_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty );
+
+PropertyRegistration property18( typeRegistration, "marks", Toolkit::Slider::MARKS_PROPERTY, Property::ARRAY, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property19( typeRegistration, "snap-to-marks", Toolkit::Slider::SNAP_TO_MARKS_PROPERTY, Property::BOOLEAN, &Slider::SetProperty, &Slider::GetProperty );
+PropertyRegistration property20( typeRegistration, "mark-tolerance", Toolkit::Slider::MARK_TOLERANCE_PROPERTY, Property::FLOAT, &Slider::SetProperty, &Slider::GetProperty );
+
} // namespace
///////////////////////////////////////////////////////////////////////////////////////////////////
Slider::Slider()
: ControlImpl( true ),
- mState( NORMAL )
+ mState( NORMAL ),
+ mDisableColor( 0.0f, 0.0f, 0.0f, 0.0f ),
+ mPopupTextColor( 0.0f, 0.0f, 0.0f, 0.0f ),
+ mHitRegion( 0.0f, 0.0f ),
+ mBackingRegion( 0.0f, 0.0f ),
+ mHandleRegionSize( 0.0f, 0.0f ),
+ mLowerBound( 0.0f ),
+ mUpperBound( 0.0f ),
+ mValue( 0.0f ),
+ mMarkTolerance( 0.0f ),
+ mValuePrecision( 0 ),
+ mShowPopup( false ),
+ mShowValue( false ),
+ mSnapToMarks( false )
{
}
// 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 );
+ SetHitRegion( DEFAULT_HIT_REGION );
+ SetBackingRegion( DEFAULT_BACKING_REGION );
+ SetHandleRegion( DEFAULT_HANDLE_REGION );
- 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 );
+ 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 );
- 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 );
+ SetPopupTextColor( DEFAULT_POPUP_TEXT_COLOR );
- mPropertyEnabled = self.RegisterProperty( Dali::Toolkit::Slider::ENABLED_PROPERTY_NAME, DEFAULT_ENABLED, Property::READ_WRITE );
+ SetShowPopup( DEFAULT_SHOW_POPUP );
+ SetShowValue( DEFAULT_SHOW_VALUE );
- 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 );
+ SetEnabled( DEFAULT_ENABLED );
+ SetDisableColor( DEFAULT_DISABLE_COLOR );
- 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 );
+ SetSnapToMarks( DEFAULT_SNAP_TO_MARKS );
+ SetMarkTolerance( MARK_SNAP_TOLERANCE );
- 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 );
- SetEnabled( DEFAULT_ENABLED );
- UpdateLowerBound( DEFAULT_LOWER_BOUND );
- UpdateUpperBound( DEFAULT_UPPER_BOUND );
+ 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 );
if( mState == PRESSED )
{
mState = NORMAL;
- mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), Self().GetProperty( mPropertyValue ).Get<float>());
+ mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
}
}
}
SetValue( value );
DisplayPopup( value );
}
- mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), Self().GetProperty( mPropertyValue ).Get<float>());
+ mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
}
mState = NORMAL;
return mMarks;
}
+void Slider::SetSnapToMarks( bool snap )
+{
+ mSnapToMarks = snap;
+}
+
bool Slider::GetSnapToMarks() const
{
- return Self().GetProperty<bool>( mPropertySnapToMarks );
+ return mSnapToMarks;
}
Actor Slider::CreateHitRegion()
return backing;
}
-void Slider::CreateBackingImage( const std::string& imageName )
+void Slider::SetBackingImageName( const std::string& imageName )
{
if( mBacking && imageName != String::EMPTY )
{
}
}
-void Slider::SetBackingScale9( const Vector4& border )
+std::string Slider::GetBackingImageName()
{
if( mBacking )
{
- mBacking.SetStyle( ImageActor::STYLE_NINE_PATCH );
- mBacking.SetNinePatchBorder( border );
+ return mBacking.GetImage().GetFilename();
}
-}
-void Slider::SetBackingRegionSize( const Vector2& region )
-{
- if( mBacking )
- {
- mBacking.SetSize( region );
- }
+ return std::string( "" );
}
ImageActor Slider::CreateProgress()
return progress;
}
-void Slider::CreateProgressImage( const std::string& imageName )
+void Slider::SetProgressImageName( const std::string& imageName )
{
if( mProgress && imageName != String::EMPTY )
{
}
}
+std::string Slider::GetProgressImageName()
+{
+ if( mProgress )
+ {
+ return mProgress.GetImage().GetFilename();
+ }
+
+ return std::string( "" );
+}
+
+void Slider::SetPopupImageName( const std::string& imageName )
+{
+ mPopupImageName = imageName;
+}
+
+std::string Slider::GetPopupImageName()
+{
+ return mPopupImageName;
+}
+
void Slider::CreatePopupImage( const std::string& imageName )
{
if( mPopup && imageName != String::EMPTY )
}
}
-void Slider::CreatePopupArrowImage( const std::string& imageName )
+void Slider::SetPopupArrowImageName( const std::string& imageName )
{
- if( mPopupArrow && imageName != String::EMPTY )
- {
- Image image = Image::New( imageName );
- mPopupArrow.SetImage( image );
- }
+ mPopupArrowImageName = imageName;
}
-void Slider::SetProgressScale9( const Vector4& border )
+std::string Slider::GetPopupArrowImageName()
{
- if( mProgress )
- {
- mProgress.SetStyle( ImageActor::STYLE_NINE_PATCH );
- mProgress.SetNinePatchBorder( border );
- }
+ return mPopupArrowImageName;
}
-void Slider::SetPopupScale9( const Vector4& border )
+void Slider::CreatePopupArrowImage( const std::string& imageName )
{
- if( mPopup )
+ if( mPopupArrow && imageName != String::EMPTY )
{
- mPopup.SetStyle( ImageActor::STYLE_NINE_PATCH );
- mPopup.SetNinePatchBorder( border );
+ Image image = Image::New( imageName );
+ mPopupArrow.SetImage( image );
}
}
return popup;
}
-void Slider::CreateHandleImage( const std::string& imageName )
+void Slider::SetHandleImageName( const std::string& imageName )
{
if( mHandle && imageName != String::EMPTY )
{
}
}
+std::string Slider::GetHandleImageName()
+{
+ if( mHandle )
+ {
+ return mHandle.GetImage().GetFilename();
+ }
+
+ return std::string( "" );
+}
+
void Slider::ResizeHandleRegion( const Vector2& region )
{
if( mHandle )
}
}
-void Slider::UpdatePopupTextColor( const Vector4& color )
+void Slider::SetPopupTextColor( const Vector4& color )
{
- if( mValueTextView )
- {
- mValueTextView.SetColor( color );
- }
+ mPopupTextColor = color;
}
Actor Slider::CreateValueDisplay()
mBacking.Add( mHandle );
}
-void Slider::ResizeHitRegion( const Vector2& size )
+void Slider::SetHitRegion( const Vector2& size )
{
+ mHitRegion = size;
+
if( mHitArea )
{
- mHitArea.SetSize( size );
+ mHitArea.SetSize( mHitRegion );
}
}
+const Vector2& Slider::GetHitRegion() const
+{
+ return mHitRegion;
+}
+
void Slider::AddPopup()
{
if( !mValueDisplay )
mValueDisplay.SetVisible( false );
mHandle.Add( mValueDisplay );
- Actor self = Self();
- CreatePopupImage( self.GetProperty<std::string>( mPropertyPopupImageName ) );
- SetPopupScale9( GetPopupScale9Border() );
- CreatePopupArrowImage( self.GetProperty<std::string>( mPropertyPopupArrowImageName ) );
+ CreatePopupImage( GetPopupImageName() );
+ CreatePopupArrowImage( GetPopupArrowImageName() );
mValueTimer = Timer::New( VALUE_VIEW_SHOW_DURATION );
mValueTimer.TickSignal().Connect( this, &Slider::HideValueView );
return false;
}
-void Slider::OnPropertySet( Property::Index index, Property::Value propertyValue )
-{
- if( index == mPropertyLowerBound )
- {
- UpdateLowerBound( propertyValue.Get<float>() );
- }
- else if( index == mPropertyUpperBound )
- {
- UpdateUpperBound( propertyValue.Get<float>() );
- }
- else if( index == mPropertyValue )
- {
- DisplayValue( propertyValue.Get<float>(), true );
- }
- else if( index == mPropertyHitRegion )
- {
- ResizeHitRegion( propertyValue.Get<Vector2>() );
- }
- else if( index == mPropertyBackingRegion )
- {
- ResizeBackingRegion( propertyValue.Get<Vector2>() );
- }
- else if( index == mPropertyHandleRegion )
- {
- UpdateHandleRegion( propertyValue.Get<Vector2>() );
- }
- else if( index == mPropertyBackingImageName )
- {
- CreateBackingImage( propertyValue.Get<std::string>() );
- }
- else if( index == mPropertyHandleImageName )
- {
- CreateHandleImage( propertyValue.Get<std::string>() );
- }
- else if( index == mPropertyProgressImageName )
- {
- CreateProgressImage( propertyValue.Get<std::string>() );
- }
- else if( index == mPropertyPopupImageName )
- {
- CreatePopupImage( propertyValue.Get<std::string>() );
- }
- else if( index == mPropertyPopupArrowImageName )
- {
- CreatePopupArrowImage( propertyValue.Get<std::string>() );
- }
- else if( index == mPropertyBackingScale9Border )
- {
- SetBackingScale9( propertyValue.Get<Vector4>() );
- }
- else if( index == mPropertyProgressScale9Border )
- {
- SetProgressScale9( propertyValue.Get<Vector4>() );
- }
- else if( index == mPropertyPopupScale9Border )
- {
- SetPopupScale9( propertyValue.Get<Vector4>() );
- }
- else if( index == mPropertyDisableColor )
- {
- UpdateSkin();
- }
- else if( index == mPropertyPopupTextColor )
- {
- UpdatePopupTextColor( propertyValue.Get<Vector4>() );
- }
- else if( index == mPropertyValuePrecision )
- {
- DisplayValue( GetValue(), false );
- }
- else if( index == mPropertyShowPopup )
- {
- ShowPopup( propertyValue.Get<bool>() );
- }
- else if( index == mPropertyShowValue )
- {
- ShowValue( propertyValue.Get<bool>() );
- }
- else if( index == mPropertyEnabled )
- {
- SetEnabled( propertyValue.Get<bool>() );
- }
- else if( index == mPropertyMarks )
- {
- SetMarks( propertyValue.Get<Property::Array>() );
- }
- 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<float>( 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<float>( mPropertyUpperBound );
+ return mUpperBound;
}
void Slider::SetValue( float value )
{
- Self().SetProperty( mPropertyValue, value );
+ mValue = value;
+ DisplayValue( mValue, true );
}
float Slider::GetValue() const
{
- return Self().GetProperty<float>( mPropertyValue );
-}
-
-void Slider::SetHitRegion( const Vector2& region )
-{
- Self().SetProperty( mPropertyHitRegion, region );
-}
-
-Vector2 Slider::GetHitRegion() const
-{
- return Self().GetProperty<Vector2>( mPropertyHitRegion );
+ return mValue;
}
void Slider::SetBackingRegion( const Vector2& region )
{
- Self().SetProperty( mPropertyBackingRegion, region );
-}
+ mBackingRegion = region;
-void Slider::ResizeBackingRegion( const Vector2& region )
-{
- SetBackingRegionSize( region );
- ResizeProgressRegion( Vector2( 0.0f, region.y ) );
+ if( mBacking )
+ {
+ mBacking.SetSize( mBackingRegion );
+ }
- mDomain = CalcDomain( region );
+ ResizeProgressRegion( Vector2( 0.0f, mBackingRegion.y ) );
+
+ mDomain = CalcDomain( mBackingRegion );
DisplayValue( GetValue(), false ); // Set the progress bar to correct width
}
-Vector2 Slider::GetBackingRegion() const
+const Vector2& Slider::GetBackingRegion() const
{
- return Self().GetProperty<Vector2>( mPropertyBackingRegion );
+ return mBackingRegion;
}
-void Slider::UpdateHandleRegion( const Vector2& region )
+void Slider::SetHandleRegion( const Vector2& region )
{
- ResizeHandleRegion( region );
+ mHandleRegionSize = region;
+
+ ResizeHandleRegion( mHandleRegionSize );
Vector2 hitRegion = GetHitRegion();
- hitRegion.x += region.x;
+ hitRegion.x += mHandleRegionSize.x;
SetHitRegion( hitRegion );
}
-Vector2 Slider::GetHandleRegion() const
+const Vector2& Slider::GetHandleRegion() const
{
- return Self().GetProperty<Vector2>( mPropertyHandleRegion );
+ return mHandleRegionSize;
}
-Vector4 Slider::GetBackingScale9Border() const
+void Slider::SetDisableColor( const Vector4& color )
{
- return Self().GetProperty<Vector4>( mPropertyBackingScale9Border );
-}
+ mDisableColor = color;
-Vector4 Slider::GetPopupScale9Border() const
-{
- return Self().GetProperty<Vector4>( mPropertyPopupScale9Border );
+ UpdateSkin();
}
Vector4 Slider::GetDisableColor() const
{
- return Self().GetProperty<Vector4>( mPropertyDisableColor );
+ return mDisableColor;
}
Vector4 Slider::GetPopupTextColor() const
{
- return Self().GetProperty<Vector4>( mPropertyPopupTextColor );
+ return mPopupTextColor;
+}
+
+void Slider::SetValuePrecision( int precision )
+{
+ mValuePrecision = precision;
}
int Slider::GetValuePrecision() const
{
- return Self().GetProperty<int>( mPropertyValuePrecision );
+ return mValuePrecision;
}
-void Slider::ShowPopup( bool showPopup )
+void Slider::SetShowPopup( bool showPopup )
{
+ mShowPopup = showPopup;
+
// Value display
- if( showPopup )
+ if( mShowPopup )
{
AddPopup();
}
bool Slider::GetShowPopup() const
{
- return Self().GetProperty<bool>( mPropertyShowPopup );
+ return mShowPopup;
}
-void Slider::ShowValue( bool showValue )
+void Slider::SetShowValue( bool showValue )
{
- if( showValue )
+ mShowValue = showValue;
+
+ if( mShowValue )
{
CreateHandleValueDisplay();
}
bool Slider::GetShowValue() const
{
- return Self().GetProperty<bool>( mPropertyShowValue );
+ return mShowValue;
}
void Slider::SetEnabled( bool enabled )
return mState != DISABLED;
}
+void Slider::SetMarkTolerance( float tolerance )
+{
+ mMarkTolerance = tolerance;
+}
+
float Slider::GetMarkTolerance() const
{
- return Self().GetProperty<float>( mPropertyMarkTolerance );
+ return mMarkTolerance;
}
// static class method to support script connecting signals
{
slider.MarkSignal().Connect( tracker, functor );
}
- else
+ else
{
// signalName does not match any signal
connected = false;
void Slider::DisplayPopup( float value )
{
- // Value display
+ // Value displayDoConnectSignal
if( mValueTextView )
{
std::stringstream ss;
}
}
+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::LOWER_BOUND_PROPERTY:
+ {
+ sliderImpl.SetLowerBound( value.Get< float >() );
+ break;
+ }
+
+ case Toolkit::Slider::UPPER_BOUND_PROPERTY:
+ {
+ sliderImpl.SetUpperBound( value.Get< float >() );
+ break;
+ }
+
+ case Toolkit::Slider::VALUE_PROPERTY:
+ {
+ sliderImpl.SetValue( value.Get< float >() );
+ break;
+ }
+
+ case Toolkit::Slider::HIT_REGION_PROPERTY:
+ {
+ sliderImpl.SetHitRegion( value.Get< Vector2 >() );
+ break;
+ }
+
+ case Toolkit::Slider::BACKING_REGION_PROPERTY:
+ {
+ sliderImpl.SetBackingRegion( value.Get< Vector2 >() );
+ break;
+ }
+
+ case Toolkit::Slider::HANDLE_REGION_PROPERTY:
+ {
+ sliderImpl.SetHandleRegion( value.Get< Vector2 >() );
+ break;
+ }
+
+ case Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY:
+ {
+ sliderImpl.SetBackingImageName( value.Get< std::string >() );
+ break;
+ }
+
+ case Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY:
+ {
+ sliderImpl.SetHandleImageName( value.Get< std::string >() );
+ break;
+ }
+
+ case Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY:
+ {
+ sliderImpl.SetProgressImageName( value.Get< std::string >() );
+ break;
+ }
+
+ case Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY:
+ {
+ sliderImpl.SetPopupImageName( value.Get< std::string >() );
+ break;
+ }
+
+ case Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY:
+ {
+ sliderImpl.SetPopupArrowImageName( value.Get< std::string >() );
+ break;
+ }
+
+ case Toolkit::Slider::DISABLE_COLOR_PROPERTY:
+ {
+ sliderImpl.SetDisableColor( value.Get< Vector4 >() );
+ break;
+ }
+
+ case Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY:
+ {
+ sliderImpl.SetPopupTextColor( value.Get< Vector4 >() );
+ break;
+ }
+
+ case Toolkit::Slider::VALUE_PRECISION_PROPERTY:
+ {
+ sliderImpl.SetValuePrecision( value.Get< int >() );
+ break;
+ }
+
+ case Toolkit::Slider::SHOW_POPUP_PROPERTY:
+ {
+ sliderImpl.SetShowPopup( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::Slider::SHOW_VALUE_PROPERTY:
+ {
+ sliderImpl.SetShowValue( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::Slider::ENABLED_PROPERTY:
+ {
+ sliderImpl.SetEnabled( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::Slider::MARKS_PROPERTY:
+ {
+ sliderImpl.SetMarks( value.Get< Property::Array >() );
+ break;
+ }
+
+ case Toolkit::Slider::SNAP_TO_MARKS_PROPERTY:
+ {
+ sliderImpl.SetSnapToMarks( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::Slider::MARK_TOLERANCE_PROPERTY:
+ {
+ 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::LOWER_BOUND_PROPERTY:
+ {
+ value = sliderImpl.GetLowerBound();
+ break;
+ }
+
+ case Toolkit::Slider::UPPER_BOUND_PROPERTY:
+ {
+ value = sliderImpl.GetUpperBound();
+ break;
+ }
+
+ case Toolkit::Slider::VALUE_PROPERTY:
+ {
+ value = sliderImpl.GetValue();
+ break;
+ }
+
+ case Toolkit::Slider::HIT_REGION_PROPERTY:
+ {
+ value = sliderImpl.GetHitRegion();
+ break;
+ }
+
+ case Toolkit::Slider::BACKING_REGION_PROPERTY:
+ {
+ value = sliderImpl.GetBackingRegion();
+ break;
+ }
+
+ case Toolkit::Slider::HANDLE_REGION_PROPERTY:
+ {
+ value = sliderImpl.GetHandleRegion();
+ break;
+ }
+
+ case Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY:
+ {
+ value = sliderImpl.GetBackingImageName();
+ break;
+ }
+
+ case Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY:
+ {
+ value = sliderImpl.GetHandleImageName();
+ break;
+ }
+
+ case Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY:
+ {
+ value = sliderImpl.GetProgressImageName();
+ break;
+ }
+
+ case Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY:
+ {
+ value = sliderImpl.GetPopupImageName();
+ break;
+ }
+
+ case Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY:
+ {
+ value = sliderImpl.GetPopupArrowImageName();
+ break;
+ }
+
+ case Toolkit::Slider::DISABLE_COLOR_PROPERTY:
+ {
+ value = sliderImpl.GetDisableColor();
+ break;
+ }
+
+ case Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY:
+ {
+ value = sliderImpl.GetPopupTextColor();
+ break;
+ }
+
+ case Toolkit::Slider::VALUE_PRECISION_PROPERTY:
+ {
+ value = sliderImpl.GetValuePrecision();
+ break;
+ }
+
+ case Toolkit::Slider::SHOW_POPUP_PROPERTY:
+ {
+ value = sliderImpl.GetShowPopup();
+ break;
+ }
+
+ case Toolkit::Slider::SHOW_VALUE_PROPERTY:
+ {
+ value = sliderImpl.GetShowValue();
+ break;
+ }
+
+ case Toolkit::Slider::ENABLED_PROPERTY:
+ {
+ value = sliderImpl.IsEnabled();
+ break;
+ }
+
+ case Toolkit::Slider::MARKS_PROPERTY:
+ {
+ // TODO: Need to be able to return a PropertyArray
+ // value = sliderImpl.GetMarks();
+ break;
+ }
+
+ case Toolkit::Slider::SNAP_TO_MARKS_PROPERTY:
+ {
+ value = sliderImpl.GetSnapToMarks();
+ break;
+ }
+
+ case Toolkit::Slider::MARK_TOLERANCE_PROPERTY:
+ {
+ value = sliderImpl.GetMarkTolerance();
+ break;
+ }
+ }
+ }
+
+ return value;
+}
} // namespace Internal
*
* @return The hit region
*/
- Vector2 GetHitRegion() const;
+ const Vector2& GetHitRegion() const;
/**
* Set backing region
*
* @return The backing region
*/
- Vector2 GetBackingRegion() const;
+ const Vector2& GetBackingRegion() const;
/**
- * Get backing scale9 border
+ * @brief Set the disable color.
*
- * @return The backing scale9 border
+ * @param[in] color The disable color.
*/
- Vector4 GetBackingScale9Border() const;
+ void SetDisableColor( const Vector4& color );
/**
- * Get popup scale9 border
- *
- * @return The popup scale9 border
- */
- Vector4 GetPopupScale9Border() const;
-
- /**
- * Get disable color
+ * @brief Get disable color
*
* @return The disable color
*/
Vector4 GetPopupTextColor() const;
/**
+ * Set the value precision to be used for numbers in the slider
+ *
+ * @param[in] precision The number of decimal places to use for printing numbers
+ */
+ void SetValuePrecision( int precision );
+
+ /**
* Get value precision
*
* @return The value precision
*
* @param[in] showPopup The show popup flag
*/
- void ShowPopup( bool showPopup );
+ void SetShowPopup( bool showPopup );
/**
* Get show value in popup
*
* @param[in] showValue The show value flag
*/
- void ShowValue( bool showValue );
+ void SetShowValue( bool showValue );
/**
* Get show value on handle
bool IsEnabled() const;
/**
+ * @brief Set the mark tolerance
+ *
+ * The tolerance is the percentage of the slider width for which snapping to
+ * marks occurs
+ *
+ * @param[in] tolerance The percentage of width for which to snap
+ */
+ void SetMarkTolerance( float tolerance );
+
+ /**
* Return the mark tolerance
*
* @return The tolerance set for snapping to marks
static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName,
FunctorDelegate* functor );
+ // Properties
+
+ /**
+ * Called when a property of an object of this type is set.
+ * @param[in] object The object whose property is set.
+ * @param[in] index The property index.
+ * @param[in] value The new property value.
+ */
+ static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
+
+ /**
+ * Called to retrieve a property of an object of this type.
+ * @param[in] object The object whose property is to be retrieved.
+ * @param[in] index The property index.
+ * @return The current value of the property.
+ */
+ static Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex );
+
protected:
/**
void CreateChildren();
/**
- * Resize the hit area
- *
- * @param[in] size The new size of the hit area
- */
- void ResizeHitRegion( const Vector2& size );
-
- /**
* Create value popup
*/
void AddPopup();
*
* @param[in] imageName The name of the image to load and set
*/
- void CreateBackingImage( const std::string& imageName );
+ void SetBackingImageName( const std::string& imageName );
/**
- * Set the backing image to be a scale-9 image
+ * @brief Return the backing image file name.
*
- * @param[in] border The scale-9 border to use
+ * @return The backing image file name.
*/
- void SetBackingScale9( const Vector4& border );
+ std::string GetBackingImageName();
/**
- * Resize the backing region
+ * Create the image for the progress bar
*
- * @param[in] region The size of the region to set
+ * @param[in] imageName The name of the image to load and set
*/
- void ResizeBackingRegion( const Vector2& region );
+ void SetProgressImageName( const std::string& imageName );
/**
- * Size the backing region
+ * @brief Return the progress image name.
*
- * @param[in] region The size of the region to set
+ * @return The progress image name if it exists.
*/
- void SetBackingRegionSize( const Vector2& region );
+ std::string GetProgressImageName();
/**
- * Create the image for the progress bar
+ * @brief Create the image for the popup
*
* @param[in] imageName The name of the image to load and set
*/
- void CreateProgressImage( const std::string& imageName );
+ void CreatePopupImage( const std::string& imageName );
/**
- * Create the image for the popup
+ * @brief Set the popup name
*
- * @param[in] imageName The name of the image to load and set
+ * @param[in] imageName The name of the image to set
*/
- void CreatePopupImage( const std::string& imageName );
+ void SetPopupImageName( const std::string& imageName );
/**
- * Create the image for the popup arrow
+ * @brief Return the popup image name.
*
- * @param[in] imageName The name of the image to load and set
+ * @return The name of the popup image if it exists.
*/
- void CreatePopupArrowImage( const std::string& imageName );
+ std::string GetPopupImageName();
/**
- * Set the progress image to be a scale-9 image
+ * @brief Set the popup arrow image name
*
- * @param[in] border The scale-9 border to use
+ * @param[in] imageName The name of the image to set
*/
- void SetProgressScale9( const Vector4& border );
+ void SetPopupArrowImageName( const std::string& imageName );
/**
- * Set the popup image to be a scale-9 image
+ * @brief Return the popup arrow image name.
*
- * @param[in] border The scale-9 border to use
+ * @return The name of the popup image if it exists.
*/
- void SetPopupScale9( const Vector4& border );
+ std::string GetPopupArrowImageName();
+
+ /**
+ * Create the image for the popup arrow
+ *
+ * @param[in] imageName The name of the image to load and set
+ */
+ void CreatePopupArrowImage( const std::string& imageName );
/**
* Set the size of the progress bar region
*
* @param[in] imageName The name of the image to load and set
*/
- void CreateHandleImage( const std::string& imageName );
+ void SetHandleImageName( const std::string& imageName );
+
+ /**
+ * @brief Return the handle image name.
+ *
+ * @return The name of the image handle if it exists.
+ */
+ std::string GetHandleImageName();
/**
* Set the size of the handle region
*
* @param[in] color The new color
*/
- void UpdatePopupTextColor( const Vector4& color );
+ void SetPopupTextColor( const Vector4& color );
/**
* Set handle region
*
* @param[in] region The handle region
*/
- void UpdateHandleRegion( const Vector2& region );
+ void SetHandleRegion( const Vector2& region );
/**
* Get handle region
*
* @return The handle region
*/
- Vector2 GetHandleRegion() const;
+ const Vector2& GetHandleRegion() const;
/**
* Set the lower bound of the slider's value
*
* @param[in] bound The value to set for the lower bound
*/
- void UpdateLowerBound( float bound );
+ void SetLowerBound( float bound );
/**
* Get the lower bound of the slider's value
*
* @param[in] bound The value to set for the upper bound
*/
- void UpdateUpperBound( float bound );
+ void SetUpperBound( float bound );
/**
* Get the upper bound of the slider's value
float GetUpperBound() const;
private:
- // From ControlImpl
-
- /**
- * @copydoc Dali::CustomActorImpl::OnPropertySet()
- */
- virtual void OnPropertySet( Property::Index index, Property::Value propertyValue );
-
-private:
// Undefined
Slider( const Slider& );
MarkList mMarks; ///< List of discreet marks
- // Properties
- Property::Index mPropertyLowerBound;
- Property::Index mPropertyUpperBound;
- Property::Index mPropertyValue;
- Property::Index mPropertyHitRegion;
- Property::Index mPropertyBackingRegion;
- Property::Index mPropertyHandleRegion;
-
- Property::Index mPropertyBackingImageName;
- Property::Index mPropertyHandleImageName;
- Property::Index mPropertyProgressImageName;
- Property::Index mPropertyPopupImageName;
- Property::Index mPropertyPopupArrowImageName;
-
- Property::Index mPropertyBackingScale9Border;
- Property::Index mPropertyProgressScale9Border;
- Property::Index mPropertyPopupScale9Border;
+ std::string mPopupImageName; ///< Image name for popup image
+ std::string mPopupArrowImageName; ///< Image name for popup arrow
- Property::Index mPropertyDisableColor;
- Property::Index mPropertyPopupTextColor;
+ Vector4 mDisableColor; ///< The color to tint the slider when disabled
+ Vector4 mPopupTextColor; ///< The color of the popup text
- Property::Index mPropertyValuePrecision;
+ Vector2 mHitRegion; ///< Size of hit region
+ Vector2 mBackingRegion; ///< Size of backing region
+ Vector2 mHandleRegionSize; ///< Size of the handle region
- Property::Index mPropertyShowPopup;
- Property::Index mPropertyShowValue;
+ float mLowerBound; ///< Lower bound on value
+ float mUpperBound; ///< Upper bound on value
+ float mValue; ///< Current value of slider
- Property::Index mPropertyEnabled;
+ float mMarkTolerance; ///< Tolerance in percentage of slider width for which to snap to marks
- Property::Index mPropertyMarks;
- Property::Index mPropertySnapToMarks;
- Property::Index mPropertyMarkTolerance;
+ int mValuePrecision; ///< The precision to use for outputting the value
+ bool mShowPopup : 1, ///< Show the popup or not
+ mShowValue : 1, ///< Whether to display the value number or not on the handle
+ mSnapToMarks : 1; ///< Turn on or off snapping to marks
};
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / commitdiff
