X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fslider%2Fslider-impl.cpp;h=03883d2f0dbb51f3ce7b360562809faa0f0a663f;hp=4c1b2fa331da9cf58cd28a26f03333feb4d8e5db;hb=699db00c70dc0def70d6cd57ae2ec8c553163021;hpb=935e800159c04fa5d389628add6183eb68f778ee diff --git a/dali-toolkit/internal/controls/slider/slider-impl.cpp b/dali-toolkit/internal/controls/slider/slider-impl.cpp index 4c1b2fa..03883d2 100755 --- a/dali-toolkit/internal/controls/slider/slider-impl.cpp +++ b/dali-toolkit/internal/controls/slider/slider-impl.cpp @@ -22,13 +22,14 @@ #include // for strcmp #include #include -#include +#include #include #include #include // INTERNAL INCLUDES #include +#include using namespace Dali; @@ -52,39 +53,27 @@ BaseHandle Create() // Setup properties, signals and actions using the type-registry. DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Slider, Toolkit::Control, Create ) -DALI_PROPERTY_REGISTRATION( Slider, "lower-bound", FLOAT, LOWER_BOUND ) -DALI_PROPERTY_REGISTRATION( Slider, "upper-bound", FLOAT, UPPER_BOUND ) -DALI_PROPERTY_REGISTRATION( Slider, "value", FLOAT, VALUE ) -DALI_PROPERTY_REGISTRATION( Slider, "hit-region", VECTOR2, HIT_REGION ) -DALI_PROPERTY_REGISTRATION( Slider, "backing-region", VECTOR2, BACKING_REGION ) -DALI_PROPERTY_REGISTRATION( Slider, "handle-region", VECTOR2, HANDLE_REGION ) -DALI_PROPERTY_REGISTRATION( Slider, "backing-image-name", STRING, BACKING_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Slider, "handle-image-name", STRING, HANDLE_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Slider, "progress-image-name", STRING, PROGRESS_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Slider, "popup-image-name", STRING, POPUP_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Slider, "popup-arrow-image-name", STRING, POPUP_ARROW_IMAGE_NAME ) -DALI_PROPERTY_REGISTRATION( Slider, "disable-color", VECTOR4, DISABLE_COLOR ) -DALI_PROPERTY_REGISTRATION( Slider, "popup-text-color", VECTOR4, POPUP_TEXT_COLOR ) -DALI_PROPERTY_REGISTRATION( Slider, "value-precision", INTEGER, VALUE_PRECISION ) -DALI_PROPERTY_REGISTRATION( Slider, "show-popup", BOOLEAN, SHOW_POPUP ) -DALI_PROPERTY_REGISTRATION( Slider, "show-value", BOOLEAN, SHOW_VALUE ) -DALI_PROPERTY_REGISTRATION( Slider, "enabled", BOOLEAN, ENABLED ) -DALI_PROPERTY_REGISTRATION( Slider, "marks", ARRAY, MARKS ) -DALI_PROPERTY_REGISTRATION( Slider, "snap-to-marks", BOOLEAN, SNAP_TO_MARKS ) -DALI_PROPERTY_REGISTRATION( Slider, "mark-tolerance", FLOAT, MARK_TOLERANCE ) - -DALI_SIGNAL_REGISTRATION( Slider, "value-changed", SIGNAL_VALUE_CHANGED ) -DALI_SIGNAL_REGISTRATION( Slider, "mark", SIGNAL_MARK ) +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 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 @@ -96,24 +85,23 @@ const float DEFAULT_WIDTH = 0.0f; const float DEFAULT_HEIGHT = 27.0f; const float DEFAULT_HIT_HEIGHT = 72.0f; const float DEFAULT_HANDLE_HEIGHT = DEFAULT_HIT_HEIGHT; +const float POPUP_TEXT_PADDING = 10.0f; -const char* SKINNED_BACKING_IMAGE_NAME = DALI_IMAGE_DIR "slider-skin.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 = 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; @@ -146,13 +134,21 @@ Dali::Toolkit::Slider Slider::New() } Slider::Slider() -: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ), +: Control( ControlBehaviour( REQUIRES_STYLE_CHANGE_SIGNALS ) ), 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 ), @@ -177,22 +173,20 @@ void Slider::OnInitialize() 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 ); + 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 ); - SetDisableColor( DEFAULT_DISABLE_COLOR ); + SetDisabledColor( DEFAULT_DISABLED_COLOR ); SetSnapToMarks( DEFAULT_SNAP_TO_MARKS ); SetMarkTolerance( MARK_SNAP_TOLERANCE ); @@ -206,31 +200,39 @@ void Slider::OnInitialize() // 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 == TouchPoint::Up) + else if( touchState == PointState::UP ) { if( mState == PRESSED ) { @@ -315,38 +317,30 @@ Slider::Domain Slider::CalcDomain( const Vector2& currentSize ) void Slider::DisplayValue( float value, bool raiseSignals ) { - float clampledValue = Clamp( value, GetLowerBound(), GetUpperBound() ); + float clampedValue = Clamp( value, GetLowerBound(), GetUpperBound() ); - float percent = MapValuePercentage( clampledValue ); + float percent = MapValuePercentage( clampedValue ); float x = mDomain.from.x + percent * ( mDomain.to.x - mDomain.from.x ); - mHandle.SetPosition( x, 0.0f, HANDLE_Z ); + mHandle.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 ); } } @@ -354,22 +348,19 @@ void Slider::DisplayValue( float value, bool raiseSignals ) { 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( 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 @@ -392,105 +383,185 @@ 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.SetRelayoutEnabled( false ); - 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::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.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() { - ImageActor progress = ImageActor::New(); - progress.SetRelayoutEnabled( false ); + return mTrackVisual; +} + +Toolkit::ImageView Slider::CreateProgress() +{ + 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::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; + } + } } +} - return std::string( "" ); +std::string Slider::GetProgressVisual() +{ + return mProgressVisual; } -void Slider::SetPopupImageName( const std::string& imageName ) +void Slider::SetPopupVisual( const std::string& filename ) { - mPopupImageName = imageName; + mPopupVisual = filename; } -std::string Slider::GetPopupImageName() +void Slider::SetPopupVisual( Property::Map map ) { - return mPopupImageName; + 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; + } + } + } } -void Slider::CreatePopupImage( const std::string& imageName ) +std::string Slider::GetPopupVisual() { - if( mPopup && ( imageName.size() > 0 ) ) + return mPopupVisual; +} + +void Slider::CreatePopupImage( const std::string& filename ) +{ + if( mPopup && ( filename.size() > 0 ) ) { - Image image = ResourceImage::New( imageName ); + Image image = ResourceImage::New( filename ); mPopup.SetImage( image ); } } -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 ); + Image image = ResourceImage::New( filename ); mPopupArrow.SetImage( image ); } } @@ -503,24 +574,23 @@ void Slider::ResizeProgressRegion( const Vector2& region ) } } -ImageActor Slider::CreateHandle() +Toolkit::ImageView Slider::CreateHandle() { - ImageActor handle = ImageActor::New(); - handle.SetRelayoutEnabled( false ); + 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(); - arrow.SetRelayoutEnabled( false ); + 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; } @@ -528,20 +598,24 @@ ImageActor Slider::CreatePopupArrow() Toolkit::TextLabel Slider::CreatePopupText() { 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.SetZ( VALUE_DISPLAY_TEXT_Z ); + 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(); - popup.SetRelayoutEnabled( false ); + 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 ); mValueTextLabel = CreatePopupText(); popup.Add( mValueTextLabel ); @@ -549,30 +623,58 @@ ImageActor Slider::CreatePopup() 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 ) + { + mHandleVisual.clear(); + std::string filename; + if( imageValue->Get( filename ) ) + { + if( mHandle && ( filename.size() > 0 ) ) + { + mHandle.SetImage( filename ); + mHandleMap = map; + } + } + } + + Property::Value* sizeValue = map.Find( "size" ); + if( sizeValue ) { - return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl(); + Vector2 size; + if( sizeValue->Get( size ) ) + { + mHandleSize = size; + ResizeHandleSize( mHandleSize ); + + Vector2 hitRegion = GetHitRegion(); + hitRegion.x += mHandleSize.x; + SetHitRegion( hitRegion ); + } } +} - return std::string( "" ); +std::string Slider::GetHandleVisual() +{ + return mHandleVisual; } -void Slider::ResizeHandleRegion( const Vector2& region ) +void Slider::ResizeHandleSize( const Vector2& size ) { if( mHandle ) { - mHandle.SetSize( region ); + mHandle.SetSize( size ); } } @@ -581,11 +683,12 @@ 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" ); - mHandleValueTextLabel.SetDrawMode( DrawMode::OVERLAY ); mHandle.Add( mHandleValueTextLabel ); } } @@ -595,11 +698,6 @@ void Slider::DestroyHandleValueDisplay() UnparentAndReset(mHandleValueTextLabel); } -void Slider::SetPopupTextColor( const Vector4& color ) -{ - mPopupTextColor = color; -} - Actor Slider::CreateValueDisplay() { Actor popup = Actor::New(); @@ -626,9 +724,9 @@ Toolkit::Slider::ValueChangedSignalType& Slider::SlidingFinishedSignal() return mSlidingFinishedSignal; } -Toolkit::Slider::MarkSignalType& Slider::MarkSignal() +Toolkit::Slider::MarkReachedSignalType& Slider::MarkReachedSignal() { - return mMarkSignal; + return mMarkReachedSignal; } void Slider::UpdateSkin() @@ -637,17 +735,17 @@ 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: @@ -672,17 +770,17 @@ void Slider::CreateChildren() mPanDetector.DetectedSignal().Connect( this, &Slider::OnPan ); self.Add( mHitArea ); - // Background - mBacking = CreateBacking(); - self.Add( mBacking ); + // Track + mTrack = CreateTrack(); + self.Add( mTrack ); // Progress bar mProgress = CreateProgress(); - mBacking.Add( mProgress ); + mTrack.Add( mProgress ); // Handle mHandle = CreateHandle(); - mBacking.Add( mHandle ); + mProgress.Add( mHandle ); } void Slider::SetHitRegion( const Vector2& size ) @@ -708,8 +806,8 @@ void Slider::AddPopup() mValueDisplay.SetVisible( 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 ); @@ -740,9 +838,9 @@ float Slider::MarkFilter( float value ) const float MARK_TOLERANCE = GetMarkTolerance(); float mark; - for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it ) + 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 ); @@ -762,9 +860,9 @@ float Slider::SnapToMark( float value ) float closestDist = std::numeric_limits::max(); float mark; - for( MarkList::iterator it = mMarks.begin(), itEnd = mMarks.end(); it != itEnd; ++it ) + for( MarkList::SizeType i = 0; i < mMarks.Count(); ++i) { - const Property::Value& propertyValue = *it; + const Property::Value& propertyValue = mMarks[i]; propertyValue.Get( mark ); mark = MapValuePercentage( mark ); @@ -785,7 +883,7 @@ bool Slider::MarkReached( float value, int& outIndex ) // Binary search int head = 0, - tail = mMarks.size() - 1; + tail = mMarks.Size() - 1; int current; float mark; @@ -859,58 +957,53 @@ float Slider::GetValue() const 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.SetSize( 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 +Vector4 Slider::GetDisabledColor() const { - return mDisableColor; -} - -Vector4 Slider::GetPopupTextColor() const -{ - return mPopupTextColor; + return mDisabledColor; } void Slider::SetValuePrecision( int precision ) @@ -1005,7 +1098,7 @@ bool Slider::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tr } else if( 0 == strcmp( signalName.c_str(), SIGNAL_MARK ) ) { - slider.MarkSignal().Connect( tracker, functor ); + slider.MarkReachedSignal().Connect( tracker, functor ); } else { @@ -1063,63 +1156,67 @@ void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, con 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; } @@ -1141,12 +1238,6 @@ void Slider::SetProperty( BaseObject* object, Property::Index propertyIndex, con break; } - case Toolkit::Slider::Property::ENABLED: - { - sliderImpl.SetEnabled( value.Get< bool >() ); - break; - } - case Toolkit::Slider::Property::MARKS: { sliderImpl.SetMarks( value.Get< Property::Array >() ); @@ -1198,63 +1289,74 @@ Property::Value Slider::GetProperty( BaseObject* object, Property::Index propert break; } - case Toolkit::Slider::Property::HIT_REGION: - { - value = sliderImpl.GetHitRegion(); - break; - } - - case Toolkit::Slider::Property::BACKING_REGION: - { - value = sliderImpl.GetBackingRegion(); - break; - } - - case Toolkit::Slider::Property::HANDLE_REGION: + case Toolkit::Slider::Property::TRACK_VISUAL: { - 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; } @@ -1276,12 +1378,6 @@ Property::Value Slider::GetProperty( BaseObject* object, Property::Index propert break; } - case Toolkit::Slider::Property::ENABLED: - { - value = sliderImpl.IsEnabled(); - break; - } - case Toolkit::Slider::Property::MARKS: { // TODO: Need to be able to return a PropertyArray