-//
-// Copyright (c) 2014 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Flora License, Version 1.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://floralicense.org/license/
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
#include <dali-toolkit/internal/controls/slider/slider-impl.h>
-#include <dali-toolkit/public-api/controls/control-impl.h>
+// EXTERNAL INCLUDES
+#include <cstring> // for strcmp
#include <sstream>
+#include <limits>
+#include <dali/public-api/events/touch-data.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/public-api/controls/control-impl.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
using namespace Dali;
-using namespace std;
namespace Dali
{
namespace Internal
{
-namespace
+namespace // Unnamed namespace
+{
+
+BaseHandle Create()
{
-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)
+ return Dali::Toolkit::Slider::New();
+}
+
+// Setup properties, signals and actions using the type-registry.
+DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create )
+
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "lowerBound", FLOAT, LOWER_BOUND )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "upperBound", FLOAT, UPPER_BOUND )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "value", FLOAT, VALUE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "trackVisual", MAP, TRACK_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "handleVisual", MAP, HANDLE_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "progressVisual", MAP, PROGRESS_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupVisual", MAP, POPUP_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "popupArrowVisual", MAP, POPUP_ARROW_VISUAL )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "disabledColor", VECTOR4, DISABLED_COLOR )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "valuePrecision", INTEGER, VALUE_PRECISION )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showPopup", BOOLEAN, SHOW_POPUP )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "showValue", BOOLEAN, SHOW_VALUE )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "marks", ARRAY, MARKS )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "snapToMarks", BOOLEAN, SNAP_TO_MARKS )
+DALI_PROPERTY_REGISTRATION( Toolkit, Slider, "markTolerance", FLOAT, MARK_TOLERANCE )
+
+DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "valueChanged", SIGNAL_VALUE_CHANGED )
+DALI_SIGNAL_REGISTRATION( Toolkit, Slider, "mark", SIGNAL_MARK )
+
+DALI_TYPE_REGISTRATION_END()
const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
const float DEFAULT_HEIGHT = 27.0f;
const float DEFAULT_HIT_HEIGHT = 72.0f;
const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT;
+const float POPUP_TEXT_PADDING = 10.0f;
-const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.png";
-const char* SKINNED_HANDLE_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-handle.png";;
-const char* SKINNED_PROGRESS_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin-progress.png";
-const char* SKINNED_POPUP_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup.png";
-const char* SKINNED_POPUP_ARROW_IMAGE_NAME = DALI_IMAGE_DIR "slider-popup-arrow.png";
-
-const Vector4 SKINNED_BACKING_SCALE9_BORDER( 12.0f, 0.0f, 12.0f, 0.0f );
-const Vector4 SKINNED_PROGRESS_SCALE9_BORDER( 14.0f, 0.0f, 0.0f, 0.0f );
-const Vector4 SKINNED_POPUP_SCALE9_BORDER( 10.0f, 10.0f, 10.0f, 10.0f );
+const char* SKINNED_TRACK_VISUAL = 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 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;
const bool DEFAULT_SHOW_POPUP = false;
const bool DEFAULT_SHOW_VALUE = true;
const bool DEFAULT_ENABLED = true;
+const bool DEFAULT_SNAP_TO_MARKS = false;
-
-BaseHandle Create()
-{
- return Dali::Toolkit::Slider::New();
-}
-
-TypeRegistration typeRegistration( typeid(Dali::Toolkit::Slider), typeid(Dali::Toolkit::Control), Create );
-
-SignalConnectorType signalConnector1( typeRegistration, Toolkit::Slider::SIGNAL_VALUE_CHANGED, &Toolkit::Internal::Slider::DoConnectSignal );
-SignalConnectorType signalConnector2( typeRegistration, Toolkit::Slider::SIGNAL_MARK, &Toolkit::Internal::Slider::DoConnectSignal );
-
-} // namespace
+} // Unnamed namespace
///////////////////////////////////////////////////////////////////////////////////////////////////
// Slider
}
Slider::Slider()
-: ControlImpl( true ),
- mState( NORMAL )
+: Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ),
+ mState( NORMAL ),
+ mPopupVisual(""),
+ mPopupArrowVisual(""),
+ mTrackVisual(""),
+ mHandleVisual(""),
+ mProgressVisual(""),
+ mPopupMap(),
+ mTrackMap(),
+ mHandleMap(),
+ mPopupArrowMap(),
+ mDisabledColor( 0.0f, 0.0f, 0.0f, 0.0f ),
+ mHitRegion( 0.0f, 0.0f ),
+ mTrackRegion( 0.0f, 0.0f ),
+ mHandleSize( 0.0f, 0.0f ),
+ mLowerBound( 0.0f ),
+ mUpperBound( 0.0f ),
+ mValue( 0.0f ),
+ mMarkTolerance( 0.0f ),
+ mValuePrecision( 0 ),
+ mShowPopup( false ),
+ mShowValue( false ),
+ mSnapToMarks( false )
{
}
// Properties
Actor self = Self();
- // Register properties in a block so the properties are ready for the update functions
- mPropertyHitRegion = self.RegisterProperty( Dali::Toolkit::Slider::HIT_REGION_PROPERTY_NAME, DEFAULT_HIT_REGION, Property::READ_WRITE );
- mPropertyBackingRegion = self.RegisterProperty( Dali::Toolkit::Slider::BACKING_REGION_PROPERTY_NAME, DEFAULT_BACKING_REGION, Property::READ_WRITE );
- mPropertyHandleRegion = self.RegisterProperty( Dali::Toolkit::Slider::HANDLE_REGION_PROPERTY_NAME, DEFAULT_HANDLE_REGION, Property::READ_WRITE );
-
- mPropertyBackingImageName = self.RegisterProperty( Dali::Toolkit::Slider::BACKING_IMAGE_NAME_PROPERTY_NAME, SKINNED_BACKING_IMAGE_NAME, Property::READ_WRITE );
- mPropertyHandleImageName = self.RegisterProperty( Dali::Toolkit::Slider::HANDLE_IMAGE_NAME_PROPERTY_NAME, SKINNED_HANDLE_IMAGE_NAME, Property::READ_WRITE );
-
- mPropertyProgressImageName = self.RegisterProperty( Dali::Toolkit::Slider::PROGRESS_IMAGE_NAME_PROPERTY_NAME, SKINNED_PROGRESS_IMAGE_NAME, Property::READ_WRITE );
- mPropertyPopupImageName = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_IMAGE_NAME_PROPERTY_NAME, SKINNED_POPUP_IMAGE_NAME, Property::READ_WRITE );
- mPropertyPopupArrowImageName = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_ARROW_IMAGE_NAME_PROPERTY_NAME, SKINNED_POPUP_ARROW_IMAGE_NAME, Property::READ_WRITE );
-
- mPropertyBackingScale9Border = self.RegisterProperty( Dali::Toolkit::Slider::BACKING_SCALE9_BORDER_PROPERTY_NAME, SKINNED_BACKING_SCALE9_BORDER, Property::READ_WRITE );
- mPropertyProgressScale9Border = self.RegisterProperty( Dali::Toolkit::Slider::PROGRESS_SCALE9_BORDER_PROPERTY_NAME, SKINNED_PROGRESS_SCALE9_BORDER, Property::READ_WRITE );
- mPropertyPopupScale9Border = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_SCALE9_BORDER_PROPERTY_NAME, SKINNED_POPUP_SCALE9_BORDER, Property::READ_WRITE );
-
- mPropertyDisableColor = self.RegisterProperty( Dali::Toolkit::Slider::DISABLE_COLOR_PROPERTY_NAME, DEFAULT_DISABLE_COLOR, Property::READ_WRITE );
- mPropertyPopupTextColor = self.RegisterProperty( Dali::Toolkit::Slider::POPUP_TEXT_COLOR_PROPERTY_NAME, DEFAULT_POPUP_TEXT_COLOR, Property::READ_WRITE );
-
- mPropertyValuePrecision = self.RegisterProperty( Dali::Toolkit::Slider::VALUE_PRECISION_PROPERTY_NAME, DEFAULT_VALUE_PRECISION, Property::READ_WRITE );
- mPropertyShowPopup = self.RegisterProperty( Dali::Toolkit::Slider::SHOW_POPUP_PROPERTY_NAME, DEFAULT_SHOW_POPUP, Property::READ_WRITE );
- mPropertyShowValue = self.RegisterProperty( Dali::Toolkit::Slider::SHOW_VALUE_PROPERTY_NAME, DEFAULT_SHOW_VALUE, Property::READ_WRITE );
-
- mPropertyEnabled = self.RegisterProperty( Dali::Toolkit::Slider::ENABLED_PROPERTY_NAME, DEFAULT_ENABLED, Property::READ_WRITE );
-
- mPropertyMarks = self.RegisterProperty( Dali::Toolkit::Slider::MARKS_PROPERTY_NAME, mMarks, Property::READ_WRITE );
- mPropertySnapToMarks = self.RegisterProperty( Dali::Toolkit::Slider::SNAP_TO_MARKS_PROPERTY_NAME, false, Property::READ_WRITE );
- mPropertyMarkTolerance = self.RegisterProperty( Dali::Toolkit::Slider::MARK_TOLERANCE_PROPERTY_NAME, MARK_SNAP_TOLERANCE, Property::READ_WRITE );
-
- mPropertyLowerBound = self.RegisterProperty( Dali::Toolkit::Slider::LOWER_BOUND_PROPERTY_NAME, DEFAULT_LOWER_BOUND, Property::READ_WRITE );
- mPropertyUpperBound = self.RegisterProperty( Dali::Toolkit::Slider::UPPER_BOUND_PROPERTY_NAME, DEFAULT_UPPER_BOUND, Property::READ_WRITE );
- mPropertyValue = self.RegisterProperty( Dali::Toolkit::Slider::VALUE_PROPERTY_NAME, DEFAULT_VALUE, Property::READ_WRITE );
-
- ResizeHitRegion( DEFAULT_HIT_REGION );
- SetBackingRegion( DEFAULT_BACKING_REGION );
- UpdateHandleRegion( DEFAULT_HANDLE_REGION );
- CreateBackingImage( SKINNED_BACKING_IMAGE_NAME );
- CreateHandleImage( SKINNED_HANDLE_IMAGE_NAME );
- CreateProgressImage( SKINNED_PROGRESS_IMAGE_NAME );
- CreatePopupImage( SKINNED_POPUP_IMAGE_NAME );
- CreatePopupArrowImage( SKINNED_POPUP_ARROW_IMAGE_NAME );
- SetBackingScale9( SKINNED_BACKING_SCALE9_BORDER );
- SetProgressScale9( SKINNED_PROGRESS_SCALE9_BORDER );
- SetPopupScale9( SKINNED_POPUP_SCALE9_BORDER );
- UpdatePopupTextColor( DEFAULT_POPUP_TEXT_COLOR );
- ShowPopup( DEFAULT_SHOW_POPUP );
- ShowValue( DEFAULT_SHOW_VALUE );
+ SetHitRegion( DEFAULT_HIT_REGION );
+ SetTrackRegion( DEFAULT_TRACK_REGION );
+ SetHandleSize( DEFAULT_HANDLE_SIZE );
+
+ SetTrackVisual( SKINNED_TRACK_VISUAL );
+ SetHandleVisual( SKINNED_HANDLE_VISUAL );
+ SetProgressVisual( SKINNED_PROGRESS_VISUAL );
+ SetPopupVisual( SKINNED_POPUP_VISUAL );
+ SetPopupArrowVisual( SKINNED_POPUP_ARROW_VISUAL );
+
+ SetShowPopup( DEFAULT_SHOW_POPUP );
+ SetShowValue( DEFAULT_SHOW_VALUE );
+
SetEnabled( DEFAULT_ENABLED );
- UpdateLowerBound( DEFAULT_LOWER_BOUND );
- UpdateUpperBound( DEFAULT_UPPER_BOUND );
+ SetDisabledColor( DEFAULT_DISABLED_COLOR );
+
+ SetSnapToMarks( DEFAULT_SNAP_TO_MARKS );
+ SetMarkTolerance( MARK_SNAP_TOLERANCE );
+
+ SetLowerBound( DEFAULT_LOWER_BOUND );
+ SetUpperBound( DEFAULT_UPPER_BOUND );
UpdateSkin();
- DisplayValue( DEFAULT_VALUE, false ); // Run this last to display the correct value
+ SetValuePrecision( DEFAULT_VALUE_PRECISION );
+ mValue = DEFAULT_VALUE;
+ DisplayValue( mValue, false ); // Run this last to display the correct value
// Size the Slider actor to a default
self.SetSize( DEFAULT_HIT_REGION.x, DEFAULT_HIT_REGION.y );
+
+ // Connect to the touch signal
+ self.TouchSignal().Connect( this, &Slider::OnTouch );
}
-void Slider::OnControlSizeSet( const Vector3& size )
+void Slider::OnSizeSet( 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 TouchData& 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 == PointState::UP )
+ {
+ if( mState == PRESSED )
+ {
+ mState = NORMAL;
+ mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
+ }
+ }
}
return true;
}
-void Slider::OnPan( Actor actor, PanGesture gesture )
+void Slider::OnPan( Actor actor, const PanGesture& gesture )
{
// gesture.position is in local actor coordinates
if( mState != DISABLED )
}
case Gesture::Finished:
{
- if( mState == PRESSED && GetSnapToMarks() )
+ if( mState == PRESSED )
{
- float value = MapBounds( SnapToMark( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
- SetValue( value );
- DisplayPopup( value );
+ if( GetSnapToMarks() )
+ {
+ float value = MapBounds( SnapToMark( MapPercentage( gesture.position ) ), GetLowerBound(), GetUpperBound() );
+ SetValue( value );
+ DisplayPopup( value );
+ }
+ mSlidingFinishedSignal.Emit( Toolkit::Slider::DownCast( Self() ), GetValue() );
}
mState = NORMAL;
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.SetX( x );
// Progress bar
if( mProgress )
{
- if( clampledValue > 0.0f )
- {
- mProgress.SetVisible( true ); // Deliberately set this in case multiple SetValues are fired at once
- mProgress.SetSize( x, GetBackingRegion().y );
- }
- else
- {
- mProgress.SetVisible( false );
- }
+ mProgress.SetSize( x, GetTrackRegion().y );
}
// Signals
if( raiseSignals )
{
Toolkit::Slider self = Toolkit::Slider::DownCast( Self() );
- mValueChangedSignal.Emit( self, clampledValue );
+ mValueChangedSignal.Emit( self, clampedValue );
int markIndex;
if( MarkReached( percent, markIndex ) )
{
- mMarkSignal.Emit( self, markIndex );
+ mMarkReachedSignal.Emit( self, markIndex );
}
}
- if( mHandleValueTextView )
+ if( mHandleValueTextLabel )
{
std::stringstream ss;
ss.precision( GetValuePrecision() );
- ss << fixed << clampledValue;
- mHandleValueTextView.SetText( ss.str() );
+ ss << std::fixed << clampedValue;
+
+ std::string label = mHandleValueTextLabel.GetProperty<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
return mMarks;
}
+void Slider::SetSnapToMarks( bool snap )
+{
+ mSnapToMarks = snap;
+}
+
bool Slider::GetSnapToMarks() const
{
- return Self().GetProperty<bool>( mPropertySnapToMarks );
+ return mSnapToMarks;
}
Actor Slider::CreateHitRegion()
Actor hitRegion = Actor::New();
hitRegion.SetParentOrigin( ParentOrigin::CENTER );
hitRegion.SetAnchorPoint( AnchorPoint::CENTER );
- hitRegion.TouchedSignal().Connect( this, &Slider::OnTouchEvent );
+ hitRegion.TouchSignal().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.SetName("SliderTrack");
+ track.SetParentOrigin( ParentOrigin::CENTER );
+ track.SetAnchorPoint( AnchorPoint::CENTER );
+ return track;
}
-void Slider::CreateBackingImage( const std::string& imageName )
+void Slider::SetTrackVisual( const std::string& filename )
{
- if( mBacking && imageName != String::EMPTY )
+ if( mHandle && ( filename.size() > 0 ) )
{
- Image image = Image::New( imageName );
- mBacking.SetImage( image );
+ mTrack.SetImage( filename );
+ mTrackVisual = filename;
}
}
-void Slider::SetBackingScale9( const Vector4& border )
+void Slider::SetTrackVisual( Property::Map map )
{
- if( mBacking )
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- mBacking.SetStyle( ImageActor::STYLE_NINE_PATCH );
- mBacking.SetNinePatchBorder( border );
+ mTrackVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mTrack && ( filename.size() > 0 ) )
+ {
+ mTrack.SetImage( filename );
+ mTrackMap = map;
+ }
+ }
}
-}
-void Slider::SetBackingRegionSize( const Vector2& region )
-{
- if( mBacking )
+ Property::Value* sizeValue = map.Find( "size" );
+ if( sizeValue )
{
- mBacking.SetSize( region );
+ Vector2 size;
+ if( sizeValue->Get( size ) )
+ {
+ mTrackRegion = size;
+ if( mTrack )
+ {
+ mTrack.SetSize( mTrackRegion );
+ }
+
+ ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
+
+ mDomain = CalcDomain( mTrackRegion );
+
+ // Set the progress bar to correct width
+ DisplayValue( GetValue(), false );
+ }
}
}
-ImageActor Slider::CreateProgress()
+std::string Slider::GetTrackVisual()
+{
+ return mTrackVisual;
+}
+
+Toolkit::ImageView Slider::CreateProgress()
{
- ImageActor progress = ImageActor::New();
+ Toolkit::ImageView progress = Toolkit::ImageView::New();
+ progress.SetName("SliderProgress");
progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
- progress.SetZ( PROGRESS_Z );
return progress;
}
-void Slider::CreateProgressImage( const std::string& imageName )
+void Slider::SetProgressVisual( const std::string& filename )
{
- if( mProgress && imageName != String::EMPTY )
+ if( mProgress && ( filename.size() > 0 ) )
{
- Image image = Image::New( imageName );
- mProgress.SetImage( image );
+ mProgress.SetImage( filename );
+ mProgressVisual = filename;
}
}
-void Slider::CreatePopupImage( const std::string& imageName )
+void Slider::SetProgressVisual( Property::Map map )
{
- if( mPopup && imageName != String::EMPTY )
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- Image image = Image::New( imageName );
- mPopup.SetImage( image );
+ mProgressVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mProgress && ( filename.size() > 0 ) )
+ {
+ mProgress.SetImage( filename );
+ mProgressMap = map;
+ }
+ }
}
}
-void Slider::CreatePopupArrowImage( const std::string& imageName )
+std::string Slider::GetProgressVisual()
+{
+ return mProgressVisual;
+}
+
+void Slider::SetPopupVisual( const std::string& filename )
{
- if( mPopupArrow && imageName != String::EMPTY )
+ mPopupVisual = filename;
+}
+
+void Slider::SetPopupVisual( Property::Map map )
+{
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- Image image = Image::New( imageName );
- mPopupArrow.SetImage( image );
+ mPopupVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mPopup && ( filename.size() > 0 ) )
+ {
+ mPopup.SetImage( filename );
+ mPopupMap = map;
+ }
+ }
}
}
-void Slider::SetProgressScale9( const Vector4& border )
+std::string Slider::GetPopupVisual()
{
- if( mProgress )
+ return mPopupVisual;
+}
+
+void Slider::CreatePopupImage( const std::string& filename )
+{
+ if( mPopup && ( filename.size() > 0 ) )
{
- mProgress.SetStyle( ImageActor::STYLE_NINE_PATCH );
- mProgress.SetNinePatchBorder( border );
+ Image image = ResourceImage::New( filename );
+ mPopup.SetImage( image );
}
}
-void Slider::SetPopupScale9( const Vector4& border )
+void Slider::SetPopupArrowVisual( const std::string& filename )
+{
+ mPopupArrowVisual = filename;
+}
+
+void Slider::SetPopupArrowVisual( Property::Map map )
{
- if( mPopup )
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- mPopup.SetStyle( ImageActor::STYLE_NINE_PATCH );
- mPopup.SetNinePatchBorder( border );
+ mPopupArrowVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mPopupArrow && ( filename.size() > 0 ) )
+ {
+ mPopupArrow.SetImage( filename );
+ mPopupArrowMap = map;
+ }
+ }
+ }
+}
+
+std::string Slider::GetPopupArrowVisual()
+{
+ return mPopupArrowVisual;
+}
+
+void Slider::CreatePopupArrowImage( const std::string& filename )
+{
+ if( mPopupArrow && ( filename.size() > 0 ) )
+ {
+ Image image = ResourceImage::New( filename );
+ mPopupArrow.SetImage( image );
}
}
}
}
-ImageActor Slider::CreateHandle()
+Toolkit::ImageView Slider::CreateHandle()
{
- ImageActor handle = ImageActor::New();
+ Toolkit::ImageView handle = Toolkit::ImageView::New();
+ handle.SetName("SliderHandle");
handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
handle.SetAnchorPoint( AnchorPoint::CENTER );
- handle.SetZ( HANDLE_Z );
return handle;
}
-ImageActor Slider::CreatePopupArrow()
+Toolkit::ImageView Slider::CreatePopupArrow()
{
- ImageActor arrow = ImageActor::New();
+ Toolkit::ImageView arrow = Toolkit::ImageView::New();
+ arrow.SetStyleName("SliderPopupArrow");
+ arrow.SetName("SliderPopupArrow");
arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
- arrow.SetZ( HANDLE_Z );
return arrow;
}
-Toolkit::TextView Slider::CreatePopupText()
+Toolkit::TextLabel Slider::CreatePopupText()
{
- Toolkit::TextView textView = Toolkit::TextView::New();
- textView.SetParentOrigin( ParentOrigin::CENTER );
- textView.SetAnchorPoint( AnchorPoint::CENTER );
- textView.SetSizePolicy( Control::Flexible, Control::Flexible );
- textView.SetZ( VALUE_DISPLAY_TEXT_Z );
- return textView;
+ Toolkit::TextLabel textLabel = Toolkit::TextLabel::New();
+ textLabel.SetName( "SliderPopupTextLabel" );
+ textLabel.SetStyleName( "SliderPopupTextLabel" );
+ 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 ) );
+ return textLabel;
}
-ImageActor Slider::CreatePopup()
+Toolkit::ImageView Slider::CreatePopup()
{
- ImageActor popup = ImageActor::New();
+ Toolkit::ImageView popup = Toolkit::ImageView::New();
+ popup.SetName( "SliderPopup" );
popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+ popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
- mValueTextView = CreatePopupText();
- popup.Add( mValueTextView );
+ mValueTextLabel = CreatePopupText();
+ popup.Add( mValueTextLabel );
return popup;
}
-void Slider::CreateHandleImage( const std::string& imageName )
+void Slider::SetHandleVisual( const std::string& filename )
{
- if( mHandle && imageName != String::EMPTY )
+ if( mHandle && ( filename.size() > 0 ) )
{
- Image image = Image::New( imageName );
- mHandle.SetImage( image );
+ mHandle.SetImage( filename );
+ mHandleVisual = filename;
}
}
-void Slider::ResizeHandleRegion( const Vector2& region )
+void Slider::SetHandleVisual( Property::Map map )
{
- if( mHandle )
+ Property::Value* imageValue = map.Find( "url" );
+ if( imageValue )
{
- mHandle.SetSize( region );
+ mHandleVisual.clear();
+ std::string filename;
+ if( imageValue->Get( filename ) )
+ {
+ if( mHandle && ( filename.size() > 0 ) )
+ {
+ mHandle.SetImage( filename );
+ mHandleMap = map;
+ }
+ }
}
-}
-void Slider::CreateHandleValueDisplay()
-{
- if( mHandle && !mHandleValueTextView )
+ Property::Value* sizeValue = map.Find( "size" );
+ if( sizeValue )
{
- mHandleValueTextView = Toolkit::TextView::New();
- mHandleValueTextView.SetParentOrigin( ParentOrigin::CENTER );
- mHandleValueTextView.SetAnchorPoint( AnchorPoint::CENTER );
- mHandleValueTextView.SetSize( GetHandleRegion() );
- mHandleValueTextView.SetZ( HANDLE_VALUE_DISPLAY_TEXT_Z );
- mHandle.Add( mHandleValueTextView );
+ Vector2 size;
+ if( sizeValue->Get( size ) )
+ {
+ mHandleSize = size;
+ ResizeHandleSize( mHandleSize );
+
+ Vector2 hitRegion = GetHitRegion();
+ hitRegion.x += mHandleSize.x;
+ SetHitRegion( hitRegion );
+ }
}
}
-void Slider::DestroyHandleValueDisplay()
+std::string Slider::GetHandleVisual()
{
- mHandleValueTextView.Unparent();
- mHandleValueTextView.Reset();
+ return mHandleVisual;
}
-void Slider::UpdatePopupTextColor( const Vector4& color )
+void Slider::ResizeHandleSize( const Vector2& size )
{
- if( mValueTextView )
+ if( mHandle )
{
- mValueTextView.SetColor( color );
+ mHandle.SetSize( size );
}
}
+void Slider::CreateHandleValueDisplay()
+{
+ if( mHandle && !mHandleValueTextLabel )
+ {
+ mHandleValueTextLabel = Toolkit::TextLabel::New();
+ mHandleValueTextLabel.SetName("SliderHandleTextLabel");
+ mHandleValueTextLabel.SetStyleName("SliderHandleTextLabel");
+ 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 );
+ }
+}
+
+void Slider::DestroyHandleValueDisplay()
+{
+ UnparentAndReset(mHandleValueTextLabel);
+}
+
Actor Slider::CreateValueDisplay()
{
Actor popup = Actor::New();
return mValueChangedSignal;
}
-Toolkit::Slider::MarkSignalType& Slider::MarkSignal()
+Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal()
+{
+ return mSlidingFinishedSignal;
+}
+
+Toolkit::Slider::MarkReachedSignalType& Slider::MarkReachedSignal()
{
- return mMarkSignal;
+ return mMarkReachedSignal;
}
void Slider::UpdateSkin()
{
case NORMAL:
{
- mBacking.SetColor( Color::WHITE );
+ mTrack.SetColor( Color::WHITE );
mHandle.SetColor( Color::WHITE );
mProgress.SetColor( Color::WHITE );
break;
}
case DISABLED:
{
- Vector4 disableColor = GetDisableColor();
- mBacking.SetColor( disableColor );
- mHandle.SetColor( disableColor );
- mProgress.SetColor( disableColor );
+ Vector4 disabledColor = GetDisabledColor();
+ mTrack.SetColor( disabledColor );
+ mHandle.SetColor( disabledColor );
+ mProgress.SetColor( 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::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( 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;
outIndex = current;
return true;
}
+
+ if( value < mark )
+ {
+ tail = current - 1;
+ }
else
{
- if( value < mark )
- {
- tail = current - 1;
- }
- else
- {
- head = current + 1;
- }
+ head = current + 1;
}
}
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 );
+ return mValue;
}
-void Slider::SetHitRegion( const Vector2& region )
+void Slider::SetTrackRegion( const Vector2& region )
{
- Self().SetProperty( mPropertyHitRegion, region );
-}
+ mTrackRegion = region;
-Vector2 Slider::GetHitRegion() const
-{
- return Self().GetProperty<Vector2>( mPropertyHitRegion );
-}
-
-void Slider::SetBackingRegion( const Vector2& region )
-{
- Self().SetProperty( mPropertyBackingRegion, region );
-}
+ if( mTrack )
+ {
+ mTrack.SetSize( mTrackRegion );
+ }
-void Slider::ResizeBackingRegion( const Vector2& region )
-{
- SetBackingRegionSize( region );
- ResizeProgressRegion( Vector2( 0.0f, region.y ) );
+ ResizeProgressRegion( Vector2( 0.0f, mTrackRegion.y ) );
- mDomain = CalcDomain( region );
+ mDomain = CalcDomain( mTrackRegion );
DisplayValue( GetValue(), false ); // Set the progress bar to correct width
}
-Vector2 Slider::GetBackingRegion() const
+const Vector2& Slider::GetTrackRegion() const
{
- return Self().GetProperty<Vector2>( mPropertyBackingRegion );
+ return mTrackRegion;
}
-void Slider::UpdateHandleRegion( const Vector2& region )
+void Slider::SetHandleSize( const Vector2& size )
{
- ResizeHandleRegion( region );
+ mHandleSize = size;
+
+ ResizeHandleSize( mHandleSize );
Vector2 hitRegion = GetHitRegion();
- hitRegion.x += region.x;
+ hitRegion.x += mHandleSize.x;
SetHitRegion( hitRegion );
}
-Vector2 Slider::GetHandleRegion() const
+const Vector2& Slider::GetHandleSize() const
{
- return Self().GetProperty<Vector2>( mPropertyHandleRegion );
+ return mHandleSize;
}
-Vector4 Slider::GetBackingScale9Border() const
+void Slider::SetDisabledColor( const Vector4& color )
{
- return Self().GetProperty<Vector4>( mPropertyBackingScale9Border );
-}
+ mDisabledColor = color;
-Vector4 Slider::GetPopupScale9Border() const
-{
- return Self().GetProperty<Vector4>( mPropertyPopupScale9Border );
+ UpdateSkin();
}
-Vector4 Slider::GetDisableColor() const
+Vector4 Slider::GetDisabledColor() const
{
- return Self().GetProperty<Vector4>( mPropertyDisableColor );
+ return mDisabledColor;
}
-Vector4 Slider::GetPopupTextColor() const
+void Slider::SetValuePrecision( int precision )
{
- return Self().GetProperty<Vector4>( mPropertyPopupTextColor );
+ 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;
}
-float Slider::GetMarkTolerance() const
+void Slider::SetMarkTolerance( float tolerance )
{
- return Self().GetProperty<float>( mPropertyMarkTolerance );
+ mMarkTolerance = tolerance;
}
-// static class method to support script connecting signals
+float Slider::GetMarkTolerance() const
+{
+ return mMarkTolerance;
+}
+// Static class method to support script connecting signals
bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
Dali::BaseHandle handle( object );
bool connected = true;
Toolkit::Slider slider = Toolkit::Slider::DownCast( handle );
- if( signalName == Dali::Toolkit::Slider::SIGNAL_VALUE_CHANGED )
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_VALUE_CHANGED ) )
{
slider.ValueChangedSignal().Connect( tracker, functor );
}
- else if( signalName == Dali::Toolkit::Slider::SIGNAL_MARK )
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) )
{
- slider.MarkSignal().Connect( tracker, functor );
+ slider.MarkReachedSignal().Connect( tracker, functor );
}
- else
+ else
{
// signalName does not match any signal
connected = false;
void Slider::DisplayPopup( float value )
{
- // Value display
- if( mValueTextView )
+ // Value displayDoConnectSignal
+ if( mValueTextLabel )
{
std::stringstream ss;
ss.precision( GetValuePrecision() );
- ss << fixed << value;
- mValueTextView.SetText( ss.str() );
- TextStyle style;
- style.SetTextColor( GetPopupTextColor() );
- mValueTextView.SetStyleToCurrentText( style, TextStyle::COLOR);
+ ss << std::fixed << value;
+ mValueTextLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, ss.str() );
if( mValueDisplay )
{
- Font font = Font::New();
- float popupWidth = font.MeasureText( ss.str() ).x + VALUE_POPUP_MARGIN * 2.0f;
- if( popupWidth < VALUE_POPUP_MIN_WIDTH )
+ mValueDisplay.SetVisible( true );
+
+ mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
+ }
+ }
+}
+
+void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
+{
+ Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
+
+ if ( slider )
+ {
+ Slider& sliderImpl( GetImpl( slider ) );
+
+ switch ( propertyIndex )
+ {
+ case Toolkit::Slider::Property::LOWER_BOUND:
{
- popupWidth = VALUE_POPUP_MIN_WIDTH;
+ sliderImpl.SetLowerBound( value.Get< float >() );
+ break;
}
- mPopup.SetSize( popupWidth, VALUE_POPUP_HEIGHT );
- mValueDisplay.SetVisible( true );
+ case Toolkit::Slider::Property::UPPER_BOUND:
+ {
+ sliderImpl.SetUpperBound( value.Get< float >() );
+ break;
+ }
- mValueTimer.SetInterval( VALUE_VIEW_SHOW_DURATION );
+ case Toolkit::Slider::Property::VALUE:
+ {
+ sliderImpl.SetValue( value.Get< float >() );
+ break;
+ }
+
+ case Toolkit::Slider::Property::TRACK_VISUAL:
+ {
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetTrackVisual( map );
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::HANDLE_VISUAL:
+ {
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetHandleVisual( map );
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::PROGRESS_VISUAL:
+ {
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetProgressVisual( map );
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::POPUP_VISUAL:
+ {
+ std::string imageUrl;
+ if( value.Get( imageUrl ) )
+ {
+ sliderImpl.SetPopupVisual( imageUrl );
+ }
+
+ // If it is not a string, then get a Property::Map from the property if possible.
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetPopupVisual( map );
+ }
+
+ break;
+ }
+
+ case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
+ {
+ Property::Map map;
+ if( value.Get( map ) )
+ {
+ sliderImpl.SetPopupArrowVisual( map );
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::DISABLED_COLOR:
+ {
+ sliderImpl.SetDisabledColor( value.Get< Vector4 >() );
+ break;
+ }
+
+ case Toolkit::Slider::Property::VALUE_PRECISION:
+ {
+ sliderImpl.SetValuePrecision( value.Get< int >() );
+ break;
+ }
+
+ case Toolkit::Slider::Property::SHOW_POPUP:
+ {
+ sliderImpl.SetShowPopup( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::Slider::Property::SHOW_VALUE:
+ {
+ sliderImpl.SetShowValue( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::Slider::Property::MARKS:
+ {
+ sliderImpl.SetMarks( value.Get< Property::Array >() );
+ break;
+ }
+
+ case Toolkit::Slider::Property::SNAP_TO_MARKS:
+ {
+ sliderImpl.SetSnapToMarks( value.Get< bool >() );
+ break;
+ }
+
+ case Toolkit::Slider::Property::MARK_TOLERANCE:
+ {
+ sliderImpl.SetMarkTolerance( value.Get< float >() );
+ break;
+ }
}
}
}
+Property::Value Slider::GetProperty( BaseObject* object, Property::Index propertyIndex )
+{
+ Property::Value value;
+
+ Toolkit::Slider slider = Toolkit::Slider::DownCast( Dali::BaseHandle( object ) );
+
+ if ( slider )
+ {
+ Slider& sliderImpl( GetImpl( slider ) );
+
+ switch ( propertyIndex )
+ {
+ case Toolkit::Slider::Property::LOWER_BOUND:
+ {
+ value = sliderImpl.GetLowerBound();
+ break;
+ }
+
+ case Toolkit::Slider::Property::UPPER_BOUND:
+ {
+ value = sliderImpl.GetUpperBound();
+ break;
+ }
+
+ case Toolkit::Slider::Property::VALUE:
+ {
+ value = sliderImpl.GetValue();
+ break;
+ }
+
+ case Toolkit::Slider::Property::TRACK_VISUAL:
+ {
+ if( !sliderImpl.mTrackVisual.empty() )
+ {
+ value = sliderImpl.GetTrackVisual();
+ }
+ else if( !sliderImpl.mTrackMap.Empty() )
+ {
+ value = sliderImpl.mTrackMap;
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::HANDLE_VISUAL:
+ {
+ if( !sliderImpl.mHandleVisual.empty() )
+ {
+ value = sliderImpl.GetHandleVisual();
+ }
+ else if( !sliderImpl.mHandleMap.Empty() )
+ {
+ value = sliderImpl.mHandleMap;
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::PROGRESS_VISUAL:
+ {
+ if( !sliderImpl.mProgressVisual.empty() )
+ {
+ value = sliderImpl.GetProgressVisual();
+ }
+ else if( !sliderImpl.mProgressMap.Empty() )
+ {
+ value = sliderImpl.mProgressMap;
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::POPUP_VISUAL:
+ {
+ if( !sliderImpl.mPopupVisual.empty() )
+ {
+ value = sliderImpl.GetPopupVisual();
+ }
+ else if( !sliderImpl.mPopupMap.Empty() )
+ {
+ value = sliderImpl.mPopupMap;
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::POPUP_ARROW_VISUAL:
+ {
+ if( !sliderImpl.mPopupArrowVisual.empty() )
+ {
+ value = sliderImpl.GetPopupArrowVisual();
+ }
+ else if( !sliderImpl.mPopupArrowMap.Empty() )
+ {
+ value = sliderImpl.mPopupArrowMap;
+ }
+ break;
+ }
+
+ case Toolkit::Slider::Property::DISABLED_COLOR:
+ {
+ value = sliderImpl.GetDisabledColor();
+ break;
+ }
+
+ case Toolkit::Slider::Property::VALUE_PRECISION:
+ {
+ value = sliderImpl.GetValuePrecision();
+ break;
+ }
+
+ case Toolkit::Slider::Property::SHOW_POPUP:
+ {
+ value = sliderImpl.GetShowPopup();
+ break;
+ }
+
+ case Toolkit::Slider::Property::SHOW_VALUE:
+ {
+ value = sliderImpl.GetShowValue();
+ break;
+ }
+
+ case Toolkit::Slider::Property::MARKS:
+ {
+ // TODO: Need to be able to return a PropertyArray
+ // value = sliderImpl.GetMarks();
+ break;
+ }
+
+ case Toolkit::Slider::Property::SNAP_TO_MARKS:
+ {
+ value = sliderImpl.GetSnapToMarks();
+ break;
+ }
+
+ case Toolkit::Slider::Property::MARK_TOLERANCE:
+ {
+ value = sliderImpl.GetMarkTolerance();
+ break;
+ }
+ }
+ }
+
+ return value;
+}
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff